commit 32a241c28f218be149318befefa570b0fcc839cf
Author: Upstream Snapshot <snapshot@microduck.local>
Date:   Fri Aug 28 15:42:17 2026 +0800

    Import upstream snapshot c19f713c415a699a79d71cd96aa13c3104a05047
    
    Upstream: https://github.com/michaelgillett/mjlab
    Upstream-Commit: c19f713c415a699a79d71cd96aa13c3104a05047
    Upstream-Branch: main

diff --git a/.claude/commands/commit-push-pr.md b/.claude/commands/commit-push-pr.md
new file mode 100644
index 0000000..0a624d6
--- /dev/null
+++ b/.claude/commands/commit-push-pr.md
@@ -0,0 +1,19 @@
+---
+allowed-tools: Bash(git checkout --branch:*), Bash(git add:*), Bash(git status:*), Bash(git push:*), Bash(git commit:*), Bash(gh pr create:*)
+description: Commit, push, and open a PR
+---
+
+## Context
+
+- Current git status: !`git status`
+- Current git diff (staged and unstaged changes): !`git diff HEAD`
+- Current branch: !`git branch --show-current`
+
+## Your task
+
+Based on the above changes:
+1. Create a new branch if on main
+2. Create a single commit with an appropriate message
+3. Push the branch to origin
+4. Create a pull request using `gh pr create`
+5. You have the capability to call multiple tools in a single response. You MUST do all of the above in a single message. Do not use any other tools or do anything else. Do not send any other text or messages besides these tool calls.
diff --git a/.claude/commands/update-mjwarp.md b/.claude/commands/update-mjwarp.md
new file mode 100644
index 0000000..f345864
--- /dev/null
+++ b/.claude/commands/update-mjwarp.md
@@ -0,0 +1,18 @@
+---
+allowed-tools: Bash(uv lock), Bash(git checkout:*), Bash(git add:*), Bash(git status:*), Bash(git push:*), Bash(git commit:*), Bash(gh pr create:*), Edit, Read
+description: Update the mujoco-warp dependency to a given commit
+---
+
+Update the mujoco-warp dependency to commit $ARGUMENTS.
+
+Steps:
+1. Read `pyproject.toml` and find the `mujoco-warp` line under `[tool.uv.sources]`.
+2. Use Edit to replace the current `rev = "..."` value with `rev = "$ARGUMENTS"` on that line.
+3. Run `uv lock` to regenerate the lockfile.
+4. Create and switch to a new branch named `update-mjwarp/<first-8-chars-of-hash>` (e.g. `update-mjwarp/e28c6038`).
+5. Stage `pyproject.toml` and `uv.lock`, then commit with message: `Update mujoco-warp to <first-8-chars-of-hash>`.
+6. Push the branch and open a PR with title `Update mujoco-warp to <first-8-chars-of-hash>`.
+
+Important:
+- The commit hash is required. If `$ARGUMENTS` is empty, ask the user for a commit hash.
+- Do NOT modify anything else in `pyproject.toml`.
diff --git a/.claude/settings.json b/.claude/settings.json
new file mode 100644
index 0000000..6c51c58
--- /dev/null
+++ b/.claude/settings.json
@@ -0,0 +1,33 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(make:*)",
+      "Bash(uv run:*)",
+      "Bash(uv lock:*)",
+      "Bash(uv sync:*)",
+      "Bash(uv add:*)",
+      "Bash(git:*)",
+      "Bash(gh:*)",
+      "WebSearch",
+      "Skill(commit-push-pr)",
+      "Skill(pr-review-toolkit:review-pr)"
+    ]
+  },
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "uv run ruff format"
+          }
+        ]
+      }
+    ]
+  },
+  "enabledPlugins": {
+    "code-simplifier@claude-plugins-official": true,
+    "pr-review-toolkit@claude-plugins-official": true
+  }
+}
diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..986f193
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,34 @@
+# Large runtime directories
+.venv/
+logs/
+wandb/
+artifacts/
+benchmark_results/
+dist/
+
+# Build/cache
+__pycache__/
+*.pyc
+.ruff_cache/
+.pytest_cache/
+.uv-cache/
+*.egg-info/
+
+# Git/CI
+.git/
+.github/
+.gitignore
+.pre-commit-config.yaml
+
+# IDE/local
+.vscode/
+.claude/
+notebooks/
+
+# Docker
+Dockerfile
+.dockerignore
+
+# Docs build artifacts
+docs/source/_build/
+docs/source/generated/
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..ac2bbb2
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,156 @@
+name: tests
+
+on:
+  push:
+    branches: [main]
+    paths-ignore:
+      - '**.md'
+      - '**.rst'
+      - 'docs/**'
+      - 'Makefile'
+      - 'LICENSE'
+      - 'scripts/benchmarks/**'
+  pull_request:
+    branches: [main]
+    paths-ignore:
+      - '**.md'
+      - '**.rst'
+      - 'docs/**'
+      - 'Makefile'
+      - 'LICENSE'
+      - 'scripts/benchmarks/**'
+
+env:
+  UV_FROZEN: "1"
+
+jobs:
+  lint-format:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Setup uv
+        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+        with:
+          enable-cache: true
+          version: "0.12.1"
+      - name: Run lint
+        run: uvx ruff@0.16.1 check --diff
+      - name: Run format
+        run: uvx ruff@0.16.1 format --diff
+
+  tests:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+        resolution: ["locked"]
+        # Also test against a fresh resolve of the latest compatible
+        # dependencies so a new upstream release breaks a PR instead of a
+        # release.
+        include:
+          - python-version: "3.13"
+            resolution: "unlocked"
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Setup uv
+        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+        with:
+          python-version: ${{ matrix.python-version }}
+          enable-cache: true
+          version: "0.12.1"
+      - name: Restore Warp kernel cache
+        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: ~/.cache/warp
+          key: warp-kernels-${{ runner.os }}-${{ runner.arch }}-${{ matrix.python-version }}-${{ matrix.resolution }}-${{ hashFiles('uv.lock', 'mjlab/**/*.py') }}
+          restore-keys: |
+            warp-kernels-${{ runner.os }}-${{ runner.arch }}-${{ matrix.python-version }}-${{ matrix.resolution }}-
+      - name: Test with python ${{ matrix.python-version }} (locked deps)
+        if: matrix.resolution == 'locked'
+        run: uv run --extra cpu pytest
+      - name: Test with python ${{ matrix.python-version }} (latest deps)
+        if: matrix.resolution == 'unlocked'
+        env:
+          UV_FROZEN: "0"
+        run: uv run --extra cpu --upgrade pytest
+
+  pyright:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Setup uv
+        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+        with:
+          python-version: ${{ matrix.python-version }}
+          enable-cache: true
+          version: "0.12.1"
+      - name: Test with python ${{ matrix.python-version }}
+        run: uv run --extra cpu pyright
+
+  ty-check:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Setup uv
+        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+        with:
+          python-version: ${{ matrix.python-version }}
+          enable-cache: true
+          version: "0.12.1"
+      - name: Type check with python ${{ matrix.python-version }}
+        run: uv run --extra cpu ty check
+
+  stubs:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Setup uv
+        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+        with:
+          enable-cache: true
+          version: "0.12.1"
+      - name: Sync environment
+        run: uv sync --extra cpu
+      - name: Regenerate MuJoCo stubs
+        run: bash typings/generate_mujoco_stubs.sh
+      - name: Verify stubs are up to date
+        run: |
+          if ! git diff --exit-code typings/mujoco; then
+            echo "::error::MuJoCo type stubs are out of date. Run 'make stubs' and commit the result."
+            exit 1
+          fi
+
+  # Mirrors the release smoke test: build the artifacts and import mjlab from an
+  # isolated, freshly resolved install, so packaging and clean-install issues
+  # surface on the PR instead of at publish time.
+  smoke-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Setup uv
+        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+        with:
+          enable-cache: true
+          version: "0.12.1"
+      - name: Install Python 3.13
+        run: uv python install 3.13
+      - name: Build
+        run: uv build
+      # MUJOCO_GL=disable so `import mujoco` skips its GL backend import; the
+      # runner has no GL libraries and the smoke test does not render.
+      - name: Smoke test (wheel)
+        run: uv run --isolated --no-project --with dist/*.whl tests/smoke_test.py
+        env:
+          MUJOCO_GL: disable
+      - name: Smoke test (source distribution)
+        run: uv run --isolated --no-project --with dist/*.tar.gz tests/smoke_test.py
+        env:
+          MUJOCO_GL: disable
diff --git a/.github/workflows/claude-code-review.yml b/.github/workflows/claude-code-review.yml
new file mode 100644
index 0000000..7679e16
--- /dev/null
+++ b/.github/workflows/claude-code-review.yml
@@ -0,0 +1,39 @@
+name: Claude Code Review
+
+on:
+  pull_request:
+    types: [opened, synchronize, ready_for_review, reopened]
+    # Optional: Only run on specific file changes
+    # paths:
+    #   - "src/**/*.ts"
+    #   - "src/**/*.tsx"
+    #   - "src/**/*.js"
+    #   - "src/**/*.jsx"
+
+jobs:
+  claude-review:
+    if: github.event.pull_request.user.login == 'kevinzakka'
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code Review
+        id: claude-review
+        uses: anthropics/claude-code-action@be7b93b1907a4abad570368f3c74b6fe3807510b # v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          plugin_marketplaces: 'https://github.com/anthropics/claude-code.git'
+          plugins: 'code-review@claude-code-plugins'
+          prompt: '/code-review:code-review ${{ github.repository }}/pull/${{ github.event.pull_request.number }}'
+          # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md
+          # or https://code.claude.com/docs/en/cli-reference for available options
diff --git a/.github/workflows/claude.yml b/.github/workflows/claude.yml
new file mode 100644
index 0000000..daeba7a
--- /dev/null
+++ b/.github/workflows/claude.yml
@@ -0,0 +1,49 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+      actions: read # Required for Claude to read CI results on PRs
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@be7b93b1907a4abad570368f3c74b6fe3807510b # v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+
+          # This is an optional setting that allows Claude to read CI results on PRs
+          additional_permissions: |
+            actions: read
+
+          # Optional: Give a custom prompt to Claude. If this is not specified, Claude will perform the instructions specified in the comment that tagged it.
+          # prompt: 'Update the pull request description to include a summary of changes.'
+
+          # Optional: Add claude_args to customize behavior and configuration
+          # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md
+          # or https://code.claude.com/docs/en/cli-reference for available options
+          # claude_args: '--allowed-tools Bash(gh pr *)'
diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml
new file mode 100644
index 0000000..3e99fa0
--- /dev/null
+++ b/.github/workflows/docker.yml
@@ -0,0 +1,91 @@
+name: Docker
+
+on:
+  workflow_dispatch:
+
+  push:
+    branches:
+      - "main"
+
+  pull_request:
+    types:
+      - opened
+      - reopened
+      - synchronize
+      - ready_for_review
+
+concurrency:
+  group: docker-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  FORCE_COLOR: 1
+  REGISTRY: ghcr.io
+  IMAGE_NAME: mujocolab/mjlab
+
+permissions:
+  id-token: write
+  packages: write
+
+jobs:
+  check_paths:
+    runs-on: ubuntu-22.04
+    outputs:
+      build: ${{ steps.filter.outputs.any }}
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - id: filter
+        uses: dorny/paths-filter@7b450fff21473bca461d4b92ce414b9d0420d706 # v4.0.2
+        with:
+          list-files: shell
+          filters: |
+            any:
+              - ".github/workflows/docker.yml"
+              - "Dockerfile"
+
+  build:
+    needs: check_paths
+    if: ${{ needs.check_paths.outputs.build == 'true' }}
+    runs-on: ubuntu-22.04
+
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Setup Docker buildx
+        uses: docker/setup-buildx-action@bb05f3f5519dd87d3ba754cc423b652a5edd6d2c # v4.2.0
+
+      - name: Log into registry
+        uses: docker/login-action@dbcb813823bdd20940b903addbd779551569679f # v4.6.0
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract Docker metadata
+        id: meta
+        uses: docker/metadata-action@dc802804100637a589fabce1cb79ff13a1411302 # v6.2.0
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          tags: |
+            type=ref,event=branch
+            type=raw,value=latest,enable={{is_default_branch}}
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@53b7df96c91f9c12dcc8a07bcb9ccacbed38856a # v7.3.0
+        with:
+          context: .
+          push: ${{ github.ref == 'refs/heads/main' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: |
+            type=gha
+            type=registry,ref=ghcr.io/mujocolab/mjlab/mjlab:buildcache
+          cache-to: |
+            type=gha,mode=max
+            type=registry,ref=ghcr.io/mujocolab/mjlab/mjlab:buildcache,mode=max
+          platforms: linux/amd64
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 0000000..692a5c6
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,47 @@
+name: docs
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+
+env:
+  UV_FROZEN: "1"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        with:
+          python-version: '3.13'
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+        with:
+          version: "0.12.1"
+
+      - name: Build Sphinx Documentation
+        run: uv run --group docs sphinx-multiversion docs docs/_build
+
+      - name: Add root redirect
+        run: echo '<meta http-equiv="refresh" content="0; url=main/index.html">' > docs/_build/index.html
+
+      - name: Remove Sphinx build artifacts
+        run: find docs/_build -type d -name .doctrees -exec rm -rf {} +
+
+      - name: Deploy to GitHub Pages
+        uses: peaceiris/actions-gh-pages@84c30a85c19949d7eee79c4ff27748b70285e453 # v4.1.0
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./docs/_build/
+          keep_files: true
diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
new file mode 100644
index 0000000..ebcd7f0
--- /dev/null
+++ b/.github/workflows/nightly.yml
@@ -0,0 +1,37 @@
+name: nightly
+
+# Early warning: upgrade every dependency to its latest version and run the
+# test suite, so an upstream release that breaks mjlab shows up here rather than
+# in a user's install or at release time.
+
+on:
+  schedule:
+    - cron: "17 11 * * *"  # Daily at 11:17 UTC (off the hour to reduce delay).
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  latest-deps:
+    name: Test against latest dependencies (py${{ matrix.python-version }})
+    # Skip on forks; scheduled runs only make sense on the canonical repo.
+    if: github.repository == 'mujocolab/mjlab'
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.13"]
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Setup uv
+        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+        with:
+          python-version: ${{ matrix.python-version }}
+          version: "0.12.1"
+      - name: Upgrade all dependencies to latest
+        run: uv lock --upgrade
+      - name: Show dependency tree
+        run: uv tree
+      - name: Test
+        run: uv run --extra cpu pytest
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..2336ed9
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,40 @@
+name: "Publish"
+
+on:
+  push:
+    tags:
+      - v*
+
+jobs:
+  run:
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - name: Checkout
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Install uv
+        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+        with:
+          version: "0.12.1"
+      - name: Install Python 3.13
+        run: uv python install 3.13
+      - name: Build
+        run: uv build
+      # MUJOCO_GL=disable so `import mujoco` skips its GL backend import. Without
+      # it, mujoco 3.10 eagerly imports the EGL bindings at import time (mjlab
+      # defaults MUJOCO_GL=egl on Linux) and crashes on the runner, which has no
+      # GL libraries. The smoke test does not render, so disabling GL is fine.
+      - name: Smoke test (wheel)
+        run: uv run --isolated --no-project --with dist/*.whl tests/smoke_test.py
+        env:
+          MUJOCO_GL: disable
+      - name: Smoke test (source distribution)
+        run: uv run --isolated --no-project --with dist/*.tar.gz tests/smoke_test.py
+        env:
+          MUJOCO_GL: disable
+      - name: Publish
+        run: uv publish
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..4144e2b
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,19 @@
+wandb/
+logs/
+onnx/
+videos/
+__pycache__/
+MUJOCO_LOG.TXT
+debug.py
+.vscode/
+*.ipynb_checkpoints/
+motions/
+*_rerun*
+artifacts/
+.venv/
+render_robots.py
+benchmark_results/
+
+# Documentation outputs.
+**/_build/*
+**/generated/*
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..f0c2dbf
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,10 @@
+repos:
+- repo: https://github.com/astral-sh/ruff-pre-commit
+  # Ruff version.
+  rev: v0.14.14
+  hooks:
+    # Run the linter.
+    - id: ruff-check
+      args: [ --fix ]
+    # Run the formatter.
+    - id: ruff-format
diff --git a/.python-version b/.python-version
new file mode 100644
index 0000000..24ee5b1
--- /dev/null
+++ b/.python-version
@@ -0,0 +1 @@
+3.13
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..681311e
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1 @@
+CLAUDE.md
\ No newline at end of file
diff --git a/CITATION.cff b/CITATION.cff
new file mode 100644
index 0000000..b65e43f
--- /dev/null
+++ b/CITATION.cff
@@ -0,0 +1,60 @@
+# This CITATION.cff file was generated with cffinit.
+# Visit https://bit.ly/cffinit to generate yours today!
+
+cff-version: 1.2.0
+title: >-
+  mjlab: A Lightweight Framework for GPU-Accelerated Robot Learning
+message: >-
+  If you use this software, please cite it using the
+  metadata from this file.
+type: software
+authors:
+  - given-names: Kevin
+    family-names: Zakka
+    email: zakka@berkeley.edu
+  - given-names: Brent
+    family-names: Yi
+    email: brentyi@berkeley.edu
+  - given-names: Qiayuan
+    family-names: Liao
+    email: qiayuanl@berkeley.edu
+  - given-names: Louis
+    family-names: Le Lay
+    email: le.lay.louis@gmail.com
+  - given-names: Koushil
+    family-names: Sreenath
+  - given-names: Pieter
+    family-names: Abbeel
+repository-code: 'https://github.com/mujocolab/mjlab'
+keywords:
+  - mujoco
+  - mujoco-warp
+  - simulation
+  - reinforcement-learning
+  - robotics
+license: Apache-2.0
+commit: 0af4087961d6fbe573243951547eb384983aa9c9
+version: 1.6.0
+date-released: '2026-08-08'
+preferred-citation:
+  type: article
+  title: >-
+    mjlab: A Lightweight Framework for GPU-Accelerated Robot Learning
+  authors:
+    - given-names: Kevin
+      family-names: Zakka
+    - given-names: Qiayuan
+      family-names: Liao
+    - given-names: Brent
+      family-names: Yi
+    - given-names: Louis
+      family-names: Le Lay
+    - given-names: Koushil
+      family-names: Sreenath
+    - given-names: Pieter
+      family-names: Abbeel
+  year: 2026
+  url: https://arxiv.org/abs/2601.22074
+  identifiers:
+    - type: arxiv
+      value: 2601.22074
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..ac4b1db
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,60 @@
+# Development Workflow
+
+**Always use `uv run`, not python**.
+
+```sh
+
+# 1. Make changes.
+
+# 2. Type check.
+uv run ty check  # Fast
+uv run pyright  # More thorough, but slower
+
+# 3. Run tests.
+uv run pytest tests/  # Single suite
+uv run pytest tests/<test_file>.py  # Specific file
+
+# 4. Format and lint before committing.
+uv run ruff format
+uv run ruff check --fix
+```
+
+We've bundled common commands into a Makefile for convenience.
+
+```sh
+make format     # Format and lint
+make type       # Type-check
+make check      # make format && make type
+make test-fast  # Run tests excluding slow ones
+make test       # Run the full test suite
+make docs       # Build documentation
+```
+
+Always run `make check` before committing. This runs formatting, linting,
+and type checking. Do not commit code that fails type checking.
+
+Before creating a PR, ensure all checks pass with `make test`.
+
+When making user-facing changes, add an entry to `docs/source/changelog.rst`
+under the "Upcoming version (not yet released)" section using
+Added/Changed/Fixed categories. Reference issues with `:issue:\`123\``
+(renders as a link to the GitHub issue).
+
+# Commits and PRs
+
+- Put `Fixes #<number>` at the end of the commit message body, not in
+  the title.
+- PR body should be plain, concise prose. No section headers, checklists,
+  or structured templates. Describe the problem, what the change does, and
+  any non-obvious tradeoffs. A good PR description reads like a short
+  paragraph to a colleague, not a form.
+- PR and commit messages are rendered on GitHub, so don't hard-wrap them
+  at 88 columns. Let each sentence flow on one line.
+
+Some style guidelines to follow:
+- Line length limit is 88 columns. This applies to code, comments, and docstrings.
+- Avoid local imports unless they are strictly necessary (e.g. circular imports).
+- Tests should follow these principles:
+  - Use functions and fixtures; do not use test classes.
+  - Favor targeted, efficient tests over exhaustive edge-case coverage.
+  - Prefer running individual tests rather than the full test suite to improve iteration speed.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..4fec317
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,25 @@
+# Contributing
+
+Bug fixes and documentation improvements are always welcome. For new features, please open an issue first so we can discuss whether it fits and work out the design, as we're intentional about keeping the scope focused.
+
+## Workflow
+
+1. Fork the repository and create a feature branch.
+2. Make your changes.
+3. Ensure formatting, type checking, and tests pass: `make test-all`.
+4. Submit a pull request.
+
+Type checking (`make type`) is required, PRs that don't pass will be blocked. You can optionally install pre-commit hooks (`pre-commit install`) to catch issues early.
+
+## Changelog
+
+Add entries to the "Upcoming version" section in `docs/source/changelog.rst` under the appropriate category (Added / Changed / Fixed), following [Keep a Changelog](https://keepachangelog.com/) conventions.
+
+## Getting Help
+
+- **Issues**: https://github.com/mujocolab/mjlab/issues
+- **Discussions**: https://github.com/mujocolab/mjlab/discussions
+
+## License
+
+By contributing, you agree your contributions will be licensed under Apache 2.0.
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..1db4e56
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,36 @@
+# Refer to uv-docker-example:
+# https://github.com/astral-sh/uv-docker-example/blob/main/standalone.Dockerfile
+# Note that we use uv to launch, so we omit the second half of the example (non-UV final image)
+
+FROM nvidia/cuda:12.8.0-runtime-ubuntu24.04
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+
+ENV DEBIAN_FRONTEND=noninteractive
+RUN apt-get update && apt-get install -y \
+    git \
+    curl \
+    libegl-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV UV_COMPILE_BYTECODE=1
+ENV UV_LINK_MODE=copy
+ENV UV_PYTHON_PREFERENCE=only-managed
+
+RUN uv python install 3.13
+
+WORKDIR /app
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    --mount=type=bind,source=uv.lock,target=uv.lock \
+    --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
+    uv sync --locked --no-install-project --no-editable --no-dev
+
+ADD . /app
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --locked --no-editable --no-dev
+
+ENV MUJOCO_GL=egl
+EXPOSE 8080
+
+CMD ["uv", "run", "python", "tests/smoke_test.py"]
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..7eb574f
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025, The mjlab Developers
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..75e7754
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,74 @@
+.PHONY: sync
+sync:
+	uv sync --all-packages --extra cu128 --group dev
+
+.PHONY: sync-cpu
+sync-cpu:
+	uv sync --all-packages --extra cpu --group dev
+
+.PHONY: format
+format:
+	uv run ruff format
+	uv run ruff check --fix
+
+.PHONY: type
+type:
+	uv run ty check
+	uv run pyright
+
+.PHONY: stubs
+stubs:
+	bash typings/generate_mujoco_stubs.sh
+
+.PHONY: check
+check: format type
+
+.PHONY: test
+test:
+	uv run pytest
+
+.PHONY: test-fast
+test-fast:
+	uv run pytest -m "not slow"
+
+.PHONY: test-cpu
+test-cpu:
+	FORCE_CPU=1 uv run pytest
+
+.PHONY: test-cpu-fast
+test-cpu-fast:
+	FORCE_CPU=1 uv run pytest -m "not slow"
+
+.PHONY: test-all
+test-all: check test
+
+.PHONY: build
+build:
+	uv build
+	uv run --isolated --no-project --with dist/*.whl tests/smoke_test.py
+	uv run --isolated --no-project --with dist/*.tar.gz tests/smoke_test.py
+	@echo "Build and import test successful"
+
+.PHONY: docs
+docs:
+	uv run --group docs sphinx-build -j auto docs docs/_build
+
+.PHONY: docs-multiversion
+docs-multiversion:
+	uv run --group docs sphinx-multiversion docs docs/_build
+
+.PHONY: docs-watch
+docs-watch:
+	uv run --group docs sphinx-autobuild -j auto docs docs/_build
+
+.PHONY: publish-test
+publish-test: build
+	uv publish --publish-url https://test.pypi.org/legacy/
+
+.PHONY: publish
+publish: build
+	uv publish
+
+.PHONY: docker-build
+docker-build:
+	docker build -t mjlab:latest .
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..21eefcb
--- /dev/null
+++ b/README.md
@@ -0,0 +1,141 @@
+![Project banner](https://raw.githubusercontent.com/mujocolab/mjlab/main/docs/source/_static/mjlab-banner.jpg)
+
+# mjlab
+
+[![GitHub Actions](https://img.shields.io/github/actions/workflow/status/mujocolab/mjlab/ci.yml?branch=main)](https://github.com/mujocolab/mjlab/actions/workflows/ci.yml?query=branch%3Amain)
+[![Documentation](https://github.com/mujocolab/mjlab/actions/workflows/docs.yml/badge.svg)](https://mujocolab.github.io/mjlab/)
+[![License](https://img.shields.io/github/license/mujocolab/mjlab)](https://github.com/mujocolab/mjlab/blob/main/LICENSE)
+[![MuJoCo Warp](https://img.shields.io/badge/MuJoCo_Warp-3.11.0-blue)](https://github.com/google-deepmind/mujoco_warp/releases/tag/v3.11.0)
+[![Nightly Benchmarks](https://img.shields.io/badge/Nightly-Benchmarks-blue)](https://mujocolab.github.io/mjlab/nightly/)
+[![PyPI](https://img.shields.io/pypi/v/mjlab)](https://pypi.org/project/mjlab/)
+[![PyPI downloads](https://img.shields.io/pypi/dm/mjlab?color=blue)](https://pypistats.org/packages/mjlab)
+
+mjlab combines [Isaac Lab](https://github.com/isaac-sim/IsaacLab)'s manager-based API with [MuJoCo Warp](https://github.com/google-deepmind/mujoco_warp), a GPU-accelerated version of [MuJoCo](https://github.com/google-deepmind/mujoco).
+The framework provides composable building blocks for environment design,
+with minimal dependencies and direct access to native MuJoCo data structures.
+
+## Getting Started
+
+mjlab requires an NVIDIA GPU for training. macOS is supported for evaluation only.
+
+**Try it now:**
+
+Run the demo (no installation needed):
+
+```bash
+uvx --from mjlab --refresh demo
+```
+
+Or try in [Google Colab](https://colab.research.google.com/github/mujocolab/mjlab/blob/main/notebooks/demo.ipynb) (no local setup required).
+
+**Install from source:**
+
+```bash
+git clone https://github.com/mujocolab/mjlab.git && cd mjlab
+uv run demo
+```
+
+For alternative installation methods (PyPI, Docker), see the [Installation Guide](https://mujocolab.github.io/mjlab/main/source/installation.html).
+
+## Training Examples
+
+### 1. Velocity Tracking
+
+Train a Unitree G1 humanoid to follow velocity commands on flat terrain:
+
+```bash
+uv run train Mjlab-Velocity-Flat-Unitree-G1 --env.scene.num-envs 4096
+```
+
+**Multi-GPU Training:** Scale to multiple GPUs using `--gpu-ids`:
+
+```bash
+uv run train Mjlab-Velocity-Flat-Unitree-G1 \
+  --gpu-ids "[0, 1]" \
+  --env.scene.num-envs 4096
+```
+
+See the [Distributed Training guide](https://mujocolab.github.io/mjlab/main/source/training/distributed_training.html) for details.
+
+Evaluate a policy while training (fetches latest checkpoint from Weights & Biases):
+
+```bash
+uv run play Mjlab-Velocity-Flat-Unitree-G1 --wandb-run-path your-org/mjlab/run-id
+```
+
+### 2. Motion Imitation
+
+Train a humanoid to mimic reference motions. See the [motion imitation guide](https://mujocolab.github.io/mjlab/main/source/training/motion_imitation.html) for preprocessing setup.
+
+```bash
+uv run train Mjlab-Tracking-Flat-Unitree-G1 --registry-name your-org/motions/motion-name --env.scene.num-envs 4096
+uv run play Mjlab-Tracking-Flat-Unitree-G1 --wandb-run-path your-org/mjlab/run-id
+```
+
+### 3. Sanity-check with Dummy Agents
+
+Use built-in agents to sanity check your MDP before training:
+
+```bash
+uv run play Mjlab-Your-Task-Id --agent zero  # Sends zero actions
+uv run play Mjlab-Your-Task-Id --agent random  # Sends uniform random actions
+```
+
+When running motion-tracking tasks, add `--registry-name your-org/motions/motion-name` to the command.
+
+
+## Documentation
+
+Full documentation is available at **[mujocolab.github.io/mjlab](https://mujocolab.github.io/mjlab/)**.
+
+## Development
+
+```bash
+make test          # Run all tests
+make test-fast     # Skip slow tests
+make format        # Format and lint
+make docs          # Build docs locally
+```
+
+For development setup: `uvx pre-commit install`
+
+## Citation
+
+mjlab is used in published research and open-source robotics projects. See the [Research](https://mujocolab.github.io/mjlab/main/source/research.html) page for publications and projects, or share your own in [Show and Tell](https://github.com/mujocolab/mjlab/discussions/categories/show-and-tell).
+
+If you use mjlab in your research, please consider citing:
+
+```bibtex
+@misc{zakka2026mjlablightweightframeworkgpuaccelerated,
+  title={mjlab: A Lightweight Framework for GPU-Accelerated Robot Learning},
+  author={Kevin Zakka and Qiayuan Liao and Brent Yi and Louis Le Lay and Koushil Sreenath and Pieter Abbeel},
+  year={2026},
+  eprint={2601.22074},
+  archivePrefix={arXiv},
+  primaryClass={cs.RO},
+  url={https://arxiv.org/abs/2601.22074},
+}
+```
+
+## License
+
+mjlab is licensed under the [Apache License, Version 2.0](LICENSE).
+
+### Third-Party Code
+
+Some portions of mjlab are forked from external projects:
+
+- **`src/mjlab/utils/lab_api/`** — Utilities forked from [NVIDIA Isaac
+  Lab](https://github.com/isaac-sim/IsaacLab) (BSD-3-Clause license, see file
+  headers)
+
+Forked components retain their original licenses. See file headers for details.
+
+## Acknowledgments
+
+mjlab wouldn't exist without the excellent work of the Isaac Lab team, whose API
+design and abstractions mjlab builds upon.
+
+Thanks to the MuJoCo Warp team — especially Erik Frey and Taylor Howell — for
+answering our questions, giving helpful feedback, and implementing features
+based on our requests countless times.
diff --git a/RELEASING.md b/RELEASING.md
new file mode 100644
index 0000000..84a9b93
--- /dev/null
+++ b/RELEASING.md
@@ -0,0 +1,76 @@
+# Releasing
+
+## Pre-release checklist
+
+1. Bump `version` in `pyproject.toml`.
+2. Update `version` and `date-released` in `CITATION.cff`.
+3. Update the "Upcoming version (not yet released)" heading in `docs/source/changelog.rst` to the new version number and date.
+4. Commit the version bump, then create an annotated tag:
+
+```sh
+git tag -a vX.Y.Z -m "Release vX.Y.Z"
+git push origin vX.Y.Z
+```
+
+## Build and verify
+
+Clean previous build artifacts, then build:
+
+```sh
+rm -rf dist/
+make build
+```
+
+This runs `uv build` to produce a wheel and sdist in `dist/`, then smoke-tests
+both artifacts in isolated environments.
+
+## Test on TestPyPI (optional but recommended)
+
+Upload to TestPyPI first to catch packaging issues before the real release:
+
+```sh
+UV_PUBLISH_TOKEN=<your-testpypi-token> make publish-test
+```
+
+Then verify the upload works end-to-end. Use `--index-strategy unsafe-best-match`
+because TestPyPI won't have all dependencies and uv needs to fall back to real
+PyPI for them:
+
+```sh
+uvx --extra-index-url https://test.pypi.org/simple/ \
+    --index-strategy unsafe-best-match \
+    --from mjlab \
+    demo
+```
+
+Note: TestPyPI requires a separate account and token from real PyPI.
+Generate one at https://test.pypi.org/manage/account/token/.
+
+## Publish to PyPI
+
+```sh
+UV_PUBLISH_TOKEN=<your-pypi-token> make publish
+```
+
+Generate a token at https://pypi.org/manage/account/token/.
+
+## Post-release
+
+Verify the release installs and runs correctly. Use `--refresh` to bypass
+the `uvx` cache (which may still hold the TestPyPI version):
+
+```sh
+uvx --refresh --from mjlab demo
+```
+
+## Releasing from a past tag
+
+If the tag has already been created and HEAD has moved ahead, check out the
+tag before building:
+
+```sh
+git checkout vX.Y.Z
+make build
+make publish
+git checkout main
+```
diff --git a/docs/_templates/versioning.html b/docs/_templates/versioning.html
new file mode 100644
index 0000000..8c7af90
--- /dev/null
+++ b/docs/_templates/versioning.html
@@ -0,0 +1,13 @@
+{% if versions %}
+<div class="sidebar-version-switcher">
+  <label class="sidebar-version-label" for="version-select">Version</label>
+  <select id="version-select" class="sidebar-version-select" onchange="location = this.value;">
+    {%- for item in versions.branches %}
+    <option value="{{ item.url }}" {% if item == current_version %}selected{% endif %}>{{ item.name }}</option>
+    {%- endfor %}
+    {%- for item in versions.tags|reverse %}
+    <option value="{{ item.url }}" {% if item == current_version %}selected{% endif %}>{{ item.name }}</option>
+    {%- endfor %}
+  </select>
+</div>
+{% endif %}
diff --git a/docs/conf.py b/docs/conf.py
new file mode 100644
index 0000000..897323c
--- /dev/null
+++ b/docs/conf.py
@@ -0,0 +1,200 @@
+import os
+import sys
+
+import sphinx_book_theme
+
+sys.path.insert(0, os.path.abspath("../src"))
+sys.path.insert(0, os.path.abspath("../src/mjlab"))
+
+
+project = "mjlab"
+copyright = "2025, The mjlab Developers"
+author = "The mjlab Developers"
+
+extensions = [
+  "sphinx.ext.autodoc",
+  "sphinx.ext.autosummary",
+  "autodocsumm",
+  "myst_parser",
+  "sphinx.ext.napoleon",
+  "sphinxemoji.sphinxemoji",
+  "sphinx.ext.intersphinx",
+  "sphinx.ext.mathjax",
+  "sphinx.ext.todo",
+  "sphinx.ext.viewcode",
+  "sphinxcontrib.bibtex",
+  "sphinxcontrib.icon",
+  "sphinx_copybutton",
+  "sphinx_design",
+  "sphinx_tabs.tabs",
+  "sphinx_multiversion",
+  "sphinx.ext.extlinks",
+]
+
+extlinks = {
+  "issue": (
+    "https://github.com/mujocolab/mjlab/issues/%s",
+    "#%s",
+  ),
+}
+
+mathjax3_config = {
+  "tex": {
+    "inlineMath": [["\\(", "\\)"]],
+    "displayMath": [["\\[", "\\]"]],
+  },
+}
+
+panels_add_bootstrap_css = False
+panels_add_fontawesome_css = True
+
+source_suffix = {
+  ".rst": "restructuredtext",
+  ".md": "markdown",
+}
+
+nitpick_ignore = [
+  ("py:obj", "slice(None)"),
+]
+
+nitpick_ignore_regex = [
+  (r"py:.*", r"pxr.*"),
+  (r"py:.*", r"trimesh.*"),
+]
+
+# emoji style
+sphinxemoji_style = "twemoji"
+autodoc_typehints = "signature"
+autoclass_content = "class"
+autodoc_class_signature = "separated"
+autodoc_member_order = "bysource"
+autodoc_inherit_docstrings = True
+bibtex_bibfiles = ["source/_static/refs.bib"]
+autosummary_generate = True
+autosummary_generate_overwrite = False
+autodoc_default_options = {
+  "member-order": "bysource",
+}
+intersphinx_mapping = {
+  "python": ("https://docs.python.org/3", None),
+}
+
+exclude_patterns = [
+  "_build",
+  "_redirect",
+  "_templates",
+  "Thumbs.db",
+  ".DS_Store",
+  "README.md",
+  "licenses/*",
+]
+
+autodoc_mock_imports = [
+  "matplotlib",
+  "scipy",
+  "carb",
+  "warp",
+  "pxr",
+  "h5py",
+  "hid",
+  "prettytable",
+  "tqdm",
+  "tensordict",
+  "trimesh",
+  "toml",
+  "mjviser",
+  "mujoco_warp",
+  "gymnasium",
+  "rsl_rl",
+  "viser",
+  "wandb",
+  "torchvision",
+]
+
+suppress_warnings = [
+  "ref.python",
+  "docutils",
+]
+
+language = "en"
+
+html_title = "mjlab Documentation"
+html_theme_path = [sphinx_book_theme.get_html_theme_path()]
+html_theme = "sphinx_book_theme"
+html_favicon = "source/_static/favicon.ico"
+html_show_copyright = True
+html_show_sphinx = False
+html_last_updated_fmt = ""
+
+html_static_path = ["source/_static"]
+html_css_files = ["css/custom.css"]
+
+html_theme_options = {
+  "path_to_docs": "docs/",
+  "collapse_navigation": True,
+  "repository_url": "https://github.com/mujocolab/mjlab",
+  "use_repository_button": True,
+  "use_issues_button": True,
+  "use_edit_page_button": True,
+  "show_toc_level": 2,
+  "use_sidenotes": True,
+  "logo": {
+    "text": "mjlab Documentation",
+  },
+  "icon_links": [
+    {
+      "name": "Benchmarks",
+      "url": "https://mujocolab.github.io/mjlab/nightly/",
+      "icon": "fa-solid fa-chart-line",
+      "type": "fontawesome",
+    },
+  ],
+  "icon_links_label": "Quick Links",
+}
+
+templates_path = [
+  "_templates",
+]
+
+smv_remote_whitelist = r"^.*$"
+smv_branch_whitelist = os.getenv("SMV_BRANCH_WHITELIST", r"^(main|devel)$")
+smv_tag_whitelist = os.getenv("SMV_TAG_WHITELIST", r"^v[1-9]\d*\.\d+\.\d+$")
+
+html_sidebars = {
+  "**": [
+    "navbar-logo.html",
+    "search-field.html",
+    "versioning.html",
+    "sbt-sidebar-nav.html",
+  ]
+}
+
+
+def skip_member(app, what, name, obj, skip, options):
+  exclusions = ["from_dict", "to_dict", "replace", "copy", "validate", "__post_init__"]
+  if name in exclusions:
+    return True
+  return None
+
+
+def process_signature(app, what, name, obj, options, signature, return_annotation):
+  """Suppress the ugly __init__ signature for dataclass Cfg classes."""
+  if what == "class" and "exclude-members" in options:
+    if "__init__" in options["exclude-members"]:
+      return ("", None)
+  return None
+
+
+def process_docstring(app, what, name, obj, options, lines):
+  """Strip auto-generated dataclass docstrings (e.g. 'ClassName(*, ...)')."""
+  import dataclasses
+
+  if what == "class" and dataclasses.is_dataclass(obj):
+    if lines and lines[0].startswith(f"{obj.__name__}("):
+      lines.clear()
+
+
+def setup(app):
+  app.connect("autodoc-skip-member", skip_member)
+  app.connect("autodoc-process-signature", process_signature)
+  app.connect("autodoc-process-docstring", process_docstring)
diff --git a/docs/index.rst b/docs/index.rst
new file mode 100644
index 0000000..e6123f5
--- /dev/null
+++ b/docs/index.rst
@@ -0,0 +1,128 @@
+Welcome to mjlab!
+=================
+
+.. figure:: source/_static/mjlab-banner.jpg
+   :width: 100%
+   :alt: mjlab
+
+mjlab is a lightweight, open-source framework for robot learning that
+combines GPU-accelerated simulation with composable environments and minimal
+setup friction. It adopts the manager-based API introduced by
+`Isaac Lab <https://github.com/isaac-sim/IsaacLab>`_, where users compose
+modular building blocks for observations, rewards, and events, and pairs it
+with `MuJoCo Warp <https://github.com/google-deepmind/mujoco_warp>`_ for
+GPU-accelerated physics. The result is a framework installable with a single
+command, requiring minimal dependencies, and providing direct access to
+native `MuJoCo <https://github.com/google-deepmind/mujoco>`_ data
+structures.
+
+**Key features:**
+
+- **Composable environments:** users define observations, rewards,
+  terminations, and other MDP terms as modular building blocks
+- **Minimal dependencies:** single-command install via ``uv``, low startup
+  latency
+- **Direct MuJoCo data structures:** native ``MjModel``/``MjData`` access
+  with no translation layers
+- **PyTorch-native:** observations, rewards, and actions are PyTorch
+  tensors backed by zero-copy GPU memory sharing
+
+For more on the design decisions behind mjlab, see :doc:`source/motivation`.
+
+**Try it now** (no installation needed):
+
+.. code-block:: bash
+
+   uvx --from mjlab --refresh demo
+
+Table of Contents
+-----------------
+
+.. toctree::
+   :maxdepth: 1
+   :caption: User Guide
+
+   source/installation
+   source/tutorials
+   source/contributing
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Concepts
+
+   source/architecture_overview
+   source/entity/index
+   source/actuators
+   source/sensors/index
+   source/scene
+   source/terrain
+
+.. toctree::
+   :maxdepth: 1
+   :caption: The Manager Layer
+
+   source/environment_config
+   source/observations
+   source/actions
+   source/rewards
+   source/terminations
+   source/commands
+   source/events
+   source/randomization
+   source/curriculum
+   source/metrics
+   source/recorders
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Training & Debugging
+
+   source/training/rsl_rl
+   source/viewers
+   source/training/distributed_training
+   source/training/cloud
+   source/debugging/nan_guard
+   source/debugging/export_scene
+
+.. toctree::
+   :maxdepth: 2
+   :caption: API Reference
+
+   source/api/index
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Further Reading
+
+   source/motivation
+   source/migration_isaac_lab
+   source/faq
+   source/research
+   source/changelog
+
+License & citation
+------------------
+
+mjlab is licensed under the Apache License, Version 2.0.
+Please refer to the `LICENSE file <https://github.com/mujocolab/mjlab/blob/main/LICENSE/>`_ for details.
+
+If you use mjlab in your research, we would appreciate a citation:
+
+.. code-block:: bibtex
+
+    @article{Zakka_mjlab_A_Lightweight_2026,
+        author = {Zakka, Kevin and Liao, Qiayuan and Yi, Brent and Le Lay, Louis and Sreenath, Koushil and Abbeel, Pieter},
+        title = {{mjlab: A Lightweight Framework for GPU-Accelerated Robot Learning}},
+        url = {https://arxiv.org/abs/2601.22074},
+        year = {2026}
+    }
+
+Acknowledgments
+---------------
+
+mjlab would not exist without the excellent work of the Isaac Lab team, whose API design
+and abstractions mjlab builds upon.
+
+Thanks also to the MuJoCo Warp team — especially Erik Frey and Taylor Howell — for
+answering our questions, giving helpful feedback, and implementing features based
+on our requests countless times.
diff --git a/docs/source/_static/architecture_diagram.png b/docs/source/_static/architecture_diagram.png
new file mode 100644
index 0000000..b6e8ac8
Binary files /dev/null and b/docs/source/_static/architecture_diagram.png differ
diff --git a/docs/source/_static/changelog/mat_texid_dr.gif b/docs/source/_static/changelog/mat_texid_dr.gif
new file mode 100644
index 0000000..31c1521
Binary files /dev/null and b/docs/source/_static/changelog/mat_texid_dr.gif differ
diff --git a/docs/source/_static/changelog/native_reward.png b/docs/source/_static/changelog/native_reward.png
new file mode 100644
index 0000000..0d0c572
Binary files /dev/null and b/docs/source/_static/changelog/native_reward.png differ
diff --git a/docs/source/_static/changelog/terrain_visualizer.jpg b/docs/source/_static/changelog/terrain_visualizer.jpg
new file mode 100644
index 0000000..03a29f1
Binary files /dev/null and b/docs/source/_static/changelog/terrain_visualizer.jpg differ
diff --git a/docs/source/_static/content/cartpole-env.jpg b/docs/source/_static/content/cartpole-env.jpg
new file mode 100644
index 0000000..d65b9fb
Binary files /dev/null and b/docs/source/_static/content/cartpole-env.jpg differ
diff --git a/docs/source/_static/content/cartpole_trained.gif b/docs/source/_static/content/cartpole_trained.gif
new file mode 100644
index 0000000..0586ac5
Binary files /dev/null and b/docs/source/_static/content/cartpole_trained.gif differ
diff --git a/docs/source/_static/content/g1.png b/docs/source/_static/content/g1.png
new file mode 100644
index 0000000..52daa42
Binary files /dev/null and b/docs/source/_static/content/g1.png differ
diff --git a/docs/source/_static/content/go1.png b/docs/source/_static/content/go1.png
new file mode 100644
index 0000000..b1f5eb1
Binary files /dev/null and b/docs/source/_static/content/go1.png differ
diff --git a/docs/source/_static/content/mjlab-banner.jpg b/docs/source/_static/content/mjlab-banner.jpg
new file mode 100644
index 0000000..eed1fc7
Binary files /dev/null and b/docs/source/_static/content/mjlab-banner.jpg differ
diff --git a/docs/source/_static/content/nan_debug.gif b/docs/source/_static/content/nan_debug.gif
new file mode 100644
index 0000000..22814cd
Binary files /dev/null and b/docs/source/_static/content/nan_debug.gif differ
diff --git a/docs/source/_static/content/rough_terrain.png b/docs/source/_static/content/rough_terrain.png
new file mode 100644
index 0000000..8af9eb6
Binary files /dev/null and b/docs/source/_static/content/rough_terrain.png differ
diff --git a/docs/source/_static/content/yam.png b/docs/source/_static/content/yam.png
new file mode 100644
index 0000000..4cc444d
Binary files /dev/null and b/docs/source/_static/content/yam.png differ
diff --git a/docs/source/_static/css/custom.css b/docs/source/_static/css/custom.css
new file mode 100644
index 0000000..2a1adc8
--- /dev/null
+++ b/docs/source/_static/css/custom.css
@@ -0,0 +1,172 @@
+/*
+ * PyData Sphinx Theme — Option A (Indigo/Teal)
+ * Aesthetic: modern lab — indigo primary, teal accent, neutral grays
+ */
+
+/* LIGHT THEME */
+html[data-theme="light"] {
+    /* Brand */
+    --pst-color-primary: #4F46E5;
+    /* Indigo-600 */
+    --pst-color-secondary: #14B8A6;
+    /* Teal-500 */
+    --pst-color-secondary-highlight: #2DD4BF;
+    /* Teal-400 */
+
+    /* Links / code links */
+    --pst-color-inline-code-links: #0D9488;
+    /* Teal-600 */
+    --pst-color-link: var(--pst-color-primary);
+    --pst-color-link-hover: #4338CA;
+    /* Indigo-700 */
+
+    /* Semantic */
+    --pst-color-info: var(--pst-color-secondary);
+    --pst-color-info-highlight: var(--pst-color-secondary);
+    --pst-color-info-bg: #D1FAE5;
+    /* Teal-50 */
+    --pst-color-attention: #F59E0B;
+    /* Amber-500 */
+    --pst-color-target: #EEF2FF;
+    /* Indigo-50 */
+
+    /* Text */
+    --pst-color-text-base: #1F2937;
+    /* Slate-800 */
+    --pst-color-text-muted: #6B7280;
+    /* Slate-500 */
+
+    /* Surfaces */
+    --pst-color-background: #FFFFFF;
+    --pst-color-on-background: #FFFFFF;
+    --pst-color-surface: #F3F4F6;
+    /* Gray-100 */
+    --pst-color-on-surface: #E5E7EB;
+    /* Gray-200 */
+    --pst-color-shadow: #D1D5DB;
+    --pst-color-border: #E5E7EB;
+
+    /* Inline code */
+    --pst-color-inline-code: #0D9488;
+    /* Teal-600 */
+
+    /* Tables / hovers */
+    --pst-color-table-row-hover-bg: #EEF2FF;
+    /* Indigo-50 */
+
+    /* Accent (sparingly) */
+    --pst-color-accent: #10B981;
+    /* Emerald-500 */
+}
+
+/* DARK THEME */
+html[data-theme="dark"] {
+    /* Brand */
+    --pst-color-primary: #A5B4FC;
+    /* Indigo-300/200 mix for readability */
+    --pst-color-secondary: #5EEAD4;
+    /* Teal-300 */
+    --pst-color-secondary-highlight: #2DD4BF;
+
+    /* Links / code links */
+    --pst-color-inline-code-links: #93C5FD;
+    /* Indigo-300 */
+    --pst-color-link: var(--pst-color-primary);
+    --pst-color-link-hover: #818CF8;
+    /* Indigo-400 */
+
+    /* Semantic */
+    --pst-color-info: var(--pst-color-secondary);
+    --pst-color-info-highlight: var(--pst-color-secondary);
+    --pst-color-info-bg: #042F2E;
+    /* Deep teal */
+    --pst-color-attention: #F59E0B;
+    --pst-color-target: #1B1C2A;
+    /* Indigo-tinted surface */
+
+    /* Text */
+    --pst-color-text-base: #E5E7EB;
+    /* Gray-200 */
+    --pst-color-text-muted: #9CA3AF;
+    /* Gray-400 */
+
+    /* Surfaces */
+    --pst-color-background: #0B0C10;
+    /* Deep graphite */
+    --pst-color-on-background: #12131A;
+    --pst-color-surface: #111827;
+    /* Slate-900 */
+    --pst-color-on-surface: #1F2937;
+    /* Slate-800 */
+    --pst-color-shadow: #0F172A;
+    --pst-color-border: #2A2D3A;
+
+    /* Inline code */
+    --pst-color-inline-code: #5EEAD4;
+    /* Teal-300 */
+
+    /* Tables / hovers */
+    --pst-color-table-row-hover-bg: #1B1C2A;
+
+    /* Accent */
+    --pst-color-accent: #34D399;
+    /* Emerald-400 */
+}
+
+/* General tweaks */
+a {
+    text-decoration: none !important;
+}
+
+.bd-header-announcement a,
+.bd-header-version-warning a {
+    color: #5EEAD4;
+}
+
+.form-control {
+    border-radius: 0 !important;
+    border: none !important;
+    outline: none !important;
+}
+
+.navbar-brand,
+.navbar-icon-links {
+    padding-top: 0rem !important;
+    padding-bottom: 0rem !important;
+}
+
+/* Version switcher */
+.sidebar-version-switcher {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.4rem 1rem;
+    margin-bottom: 0.5rem;
+}
+
+.sidebar-version-label {
+    font-size: 0.8rem;
+    font-weight: 600;
+    color: var(--pst-color-text-muted);
+    white-space: nowrap;
+}
+
+.sidebar-version-select {
+    flex: 1;
+    font-size: 0.8rem;
+    padding: 0.25rem 0.5rem;
+    border: 1px solid var(--pst-color-border);
+    border-radius: 4px;
+    background: var(--pst-color-background);
+    color: var(--pst-color-text-base);
+    cursor: pointer;
+}
+
+.sidebar-version-select:hover {
+    border-color: var(--pst-color-primary);
+}
+
+/* Sidebar section spacing */
+.bd-sidebar .navbar-icon-links {
+    padding: 0 1rem 0.25rem !important;
+}
\ No newline at end of file
diff --git a/docs/source/_static/dr_combined_rand.gif b/docs/source/_static/dr_combined_rand.gif
new file mode 100644
index 0000000..6b1a99f
Binary files /dev/null and b/docs/source/_static/dr_combined_rand.gif differ
diff --git a/docs/source/_static/dr_pseudo_inertia.gif b/docs/source/_static/dr_pseudo_inertia.gif
new file mode 100644
index 0000000..fa6f5be
Binary files /dev/null and b/docs/source/_static/dr_pseudo_inertia.gif differ
diff --git a/docs/source/_static/favicon.ico b/docs/source/_static/favicon.ico
new file mode 100644
index 0000000..2f9ce5c
Binary files /dev/null and b/docs/source/_static/favicon.ico differ
diff --git a/docs/source/_static/ghost_visualization.png b/docs/source/_static/ghost_visualization.png
new file mode 100644
index 0000000..370877b
Binary files /dev/null and b/docs/source/_static/ghost_visualization.png differ
diff --git a/docs/source/_static/mjlab-banner.jpg b/docs/source/_static/mjlab-banner.jpg
new file mode 100644
index 0000000..eed1fc7
Binary files /dev/null and b/docs/source/_static/mjlab-banner.jpg differ
diff --git a/docs/source/_static/native_viewer.png b/docs/source/_static/native_viewer.png
new file mode 100644
index 0000000..b99d592
Binary files /dev/null and b/docs/source/_static/native_viewer.png differ
diff --git a/docs/source/_static/pattern_grid.jpg b/docs/source/_static/pattern_grid.jpg
new file mode 100644
index 0000000..a259ad1
Binary files /dev/null and b/docs/source/_static/pattern_grid.jpg differ
diff --git a/docs/source/_static/pattern_grid.mp4 b/docs/source/_static/pattern_grid.mp4
new file mode 100644
index 0000000..65d4ae8
Binary files /dev/null and b/docs/source/_static/pattern_grid.mp4 differ
diff --git a/docs/source/_static/pattern_pinhole.mp4 b/docs/source/_static/pattern_pinhole.mp4
new file mode 100644
index 0000000..10c12f0
Binary files /dev/null and b/docs/source/_static/pattern_pinhole.mp4 differ
diff --git a/docs/source/_static/ray_alignment_comparison.mp4 b/docs/source/_static/ray_alignment_comparison.mp4
new file mode 100644
index 0000000..97c30b1
Binary files /dev/null and b/docs/source/_static/ray_alignment_comparison.mp4 differ
diff --git a/docs/source/_static/raycast_demo.mp4 b/docs/source/_static/raycast_demo.mp4
new file mode 100644
index 0000000..c0ba6a2
Binary files /dev/null and b/docs/source/_static/raycast_demo.mp4 differ
diff --git a/docs/source/_static/refs.bib b/docs/source/_static/refs.bib
new file mode 100644
index 0000000..e69de29
diff --git a/docs/source/_static/terrains/box_flat.png b/docs/source/_static/terrains/box_flat.png
new file mode 100644
index 0000000..c5ef0f1
Binary files /dev/null and b/docs/source/_static/terrains/box_flat.png differ
diff --git a/docs/source/_static/terrains/box_inverted_pyramid_stairs.png b/docs/source/_static/terrains/box_inverted_pyramid_stairs.png
new file mode 100644
index 0000000..c0f4495
Binary files /dev/null and b/docs/source/_static/terrains/box_inverted_pyramid_stairs.png differ
diff --git a/docs/source/_static/terrains/box_narrow_beams.png b/docs/source/_static/terrains/box_narrow_beams.png
new file mode 100644
index 0000000..f88f87f
Binary files /dev/null and b/docs/source/_static/terrains/box_narrow_beams.png differ
diff --git a/docs/source/_static/terrains/box_nested_rings.png b/docs/source/_static/terrains/box_nested_rings.png
new file mode 100644
index 0000000..0c38834
Binary files /dev/null and b/docs/source/_static/terrains/box_nested_rings.png differ
diff --git a/docs/source/_static/terrains/box_open_stairs.png b/docs/source/_static/terrains/box_open_stairs.png
new file mode 100644
index 0000000..9eff84d
Binary files /dev/null and b/docs/source/_static/terrains/box_open_stairs.png differ
diff --git a/docs/source/_static/terrains/box_pyramid_stairs.png b/docs/source/_static/terrains/box_pyramid_stairs.png
new file mode 100644
index 0000000..c4d3eff
Binary files /dev/null and b/docs/source/_static/terrains/box_pyramid_stairs.png differ
diff --git a/docs/source/_static/terrains/box_random_grid.png b/docs/source/_static/terrains/box_random_grid.png
new file mode 100644
index 0000000..681176f
Binary files /dev/null and b/docs/source/_static/terrains/box_random_grid.png differ
diff --git a/docs/source/_static/terrains/box_random_spread.png b/docs/source/_static/terrains/box_random_spread.png
new file mode 100644
index 0000000..746edb5
Binary files /dev/null and b/docs/source/_static/terrains/box_random_spread.png differ
diff --git a/docs/source/_static/terrains/box_random_stairs.png b/docs/source/_static/terrains/box_random_stairs.png
new file mode 100644
index 0000000..0b47f77
Binary files /dev/null and b/docs/source/_static/terrains/box_random_stairs.png differ
diff --git a/docs/source/_static/terrains/box_stepping_stones.png b/docs/source/_static/terrains/box_stepping_stones.png
new file mode 100644
index 0000000..cf127a0
Binary files /dev/null and b/docs/source/_static/terrains/box_stepping_stones.png differ
diff --git a/docs/source/_static/terrains/box_tilted_grid.png b/docs/source/_static/terrains/box_tilted_grid.png
new file mode 100644
index 0000000..385a576
Binary files /dev/null and b/docs/source/_static/terrains/box_tilted_grid.png differ
diff --git a/docs/source/_static/terrains/flat_patch_group.png b/docs/source/_static/terrains/flat_patch_group.png
new file mode 100644
index 0000000..60a38d3
Binary files /dev/null and b/docs/source/_static/terrains/flat_patch_group.png differ
diff --git a/docs/source/_static/terrains/hf_discrete_obstacles.png b/docs/source/_static/terrains/hf_discrete_obstacles.png
new file mode 100644
index 0000000..6d63726
Binary files /dev/null and b/docs/source/_static/terrains/hf_discrete_obstacles.png differ
diff --git a/docs/source/_static/terrains/hf_perlin_noise.png b/docs/source/_static/terrains/hf_perlin_noise.png
new file mode 100644
index 0000000..15183f7
Binary files /dev/null and b/docs/source/_static/terrains/hf_perlin_noise.png differ
diff --git a/docs/source/_static/terrains/hf_pyramid_slope.png b/docs/source/_static/terrains/hf_pyramid_slope.png
new file mode 100644
index 0000000..8866224
Binary files /dev/null and b/docs/source/_static/terrains/hf_pyramid_slope.png differ
diff --git a/docs/source/_static/terrains/hf_random_uniform.png b/docs/source/_static/terrains/hf_random_uniform.png
new file mode 100644
index 0000000..38dabbe
Binary files /dev/null and b/docs/source/_static/terrains/hf_random_uniform.png differ
diff --git a/docs/source/_static/terrains/hf_wave.png b/docs/source/_static/terrains/hf_wave.png
new file mode 100644
index 0000000..d936b23
Binary files /dev/null and b/docs/source/_static/terrains/hf_wave.png differ
diff --git a/docs/source/_static/tutorials/cartpole_swingup.mp4 b/docs/source/_static/tutorials/cartpole_swingup.mp4
new file mode 100644
index 0000000..e5a43b5
Binary files /dev/null and b/docs/source/_static/tutorials/cartpole_swingup.mp4 differ
diff --git a/docs/source/_static/tutorials/cartpole_training_curve.png b/docs/source/_static/tutorials/cartpole_training_curve.png
new file mode 100644
index 0000000..0b1b3dd
Binary files /dev/null and b/docs/source/_static/tutorials/cartpole_training_curve.png differ
diff --git a/docs/source/_static/viser_camera_pane.png b/docs/source/_static/viser_camera_pane.png
new file mode 100644
index 0000000..dd7f3a3
Binary files /dev/null and b/docs/source/_static/viser_camera_pane.png differ
diff --git a/docs/source/_static/viser_viewer.png b/docs/source/_static/viser_viewer.png
new file mode 100644
index 0000000..4fed515
Binary files /dev/null and b/docs/source/_static/viser_viewer.png differ
diff --git a/docs/source/actions.rst b/docs/source/actions.rst
new file mode 100644
index 0000000..3e8b6ec
--- /dev/null
+++ b/docs/source/actions.rst
@@ -0,0 +1,173 @@
+.. _actions:
+
+Actions
+=======
+
+Actions define how the policy controls the simulation. The action
+manager receives the policy's output tensor each step, splits it across
+registered action terms, and routes each slice to the appropriate
+entity's actuators. Each term maps a contiguous segment of the policy
+output to a control mode (position, velocity, effort) on a set of
+joints, tendons, or sites.
+
+.. code-block:: python
+
+    from mjlab.envs.mdp.actions import JointPositionActionCfg
+
+    actions = {
+        "joint_pos": JointPositionActionCfg(
+            entity_name="robot",
+            actuator_names=(".*",),   # regex matching actuator names
+            scale=0.5,
+            use_default_offset=True,  # action 0 = default pose
+        ),
+    }
+
+
+Common parameters
+-----------------
+
+All action types share a base set of parameters inherited from
+``BaseActionCfg``.
+
+``entity_name`` identifies the scene entity to control. ``actuator_names``
+is a tuple of regex patterns matched against actuator (or tendon/site)
+names to select the controlled targets.
+
+``scale`` multiplies the raw policy output before any offset is applied.
+It accepts a scalar or a dict mapping actuator name patterns to
+per-target values. This keeps policy outputs in a normalized range while
+mapping to physically meaningful units. ``offset`` is added after
+scaling; joint action types also provide ``use_default_offset``, which
+automatically loads the entity's default joint positions or velocities
+as the offset so that a raw output of zero produces the default pose.
+
+``clip`` optionally clamps the processed action (after scale and offset)
+before it reaches the actuator. It accepts a dict mapping actuator name
+patterns to ``(min, max)`` tuples, resolved the same way as ``scale``
+and ``offset``.
+
+.. code-block:: python
+
+    JointPositionActionCfg(
+        entity_name="robot",
+        actuator_names=(".*",),
+        scale=0.5,
+        clip={".*_hip_.*": (-1.0, 1.0), ".*_knee_.*": (-0.5, 2.0)},
+    )
+
+Actions are written to actuator targets on every decimation substep
+(physics step), not just once per policy step. This is in contrast to
+observation delay, which operates in units of policy steps.
+
+
+Action types
+------------
+
+.. list-table::
+   :header-rows: 1
+   :widths: 28 72
+
+   * - Type
+     - Description
+   * - ``JointPositionAction``
+     - Sets joint position targets. With ``use_default_offset=True``
+       (the default), a policy output of zero commands the default pose.
+       Encoder bias from ``dr.encoder_bias`` is subtracted automatically
+       so that randomized offsets propagate correctly to the control
+       command.
+   * - ``RelativeJointPositionAction``
+     - Sets joint position targets relative to the current joint positions.
+       The target is ``current_pos + action * scale``, so a policy output of
+       zero holds the robot in place regardless of its current configuration.
+   * - ``JointVelocityAction``
+     - Sets joint velocity targets. ``use_default_offset=True`` uses the
+       default joint velocities (typically zero).
+   * - ``JointEffortAction``
+     - Sets joint effort (torque) targets directly. No default offset.
+   * - ``TendonLengthAction``
+     - Sets tendon length targets. Targets are resolved by matching
+       ``actuator_names`` against tendon names.
+   * - ``TendonVelocityAction``
+     - Sets tendon velocity targets.
+   * - ``TendonEffortAction``
+     - Sets tendon effort targets.
+   * - ``SiteEffortAction``
+     - Applies forces and torques at named sites. Useful for
+       quadrotors and drones where thrust is applied at rotor sites
+       rather than through joint actuators.
+
+
+Task-space actions
+------------------
+
+``DifferentialIKAction`` converts Cartesian position and orientation
+commands into joint-space position targets via damped least-squares
+inverse kinematics. One IK step is executed per decimation substep, so
+the end-effector tracks the target continuously across substeps rather
+than only at policy frequency.
+
+The action dimension is selected automatically based on configuration:
+
+- ``orientation_weight == 0``: **3D** (position only)
+- ``orientation_weight > 0, use_relative_mode=True``: **6D** (delta
+  position + delta axis-angle)
+- ``orientation_weight > 0, use_relative_mode=False``: **7D** (absolute
+  position + quaternion)
+
+All objectives (position, orientation, joint limits, posture) are
+stacked into a single DLS system. Setting a weight to zero disables
+that objective with no overhead in the solve.
+
+The ``compute_dq()`` method returns joint displacements without writing
+to actuator targets, enabling multi-iteration IK in standalone scripts
+outside of RL training.
+
+
+Action dimensions and history
+------------------------------
+
+The total action dimension presented to the policy is the sum of each
+registered term's ``action_dim``. For joint, tendon, and site actions
+this equals the number of matched targets. For ``DifferentialIKAction``
+it is 3, 6, or 7 depending on the active objectives.
+
+The action manager tracks the three most recent action vectors:
+``action``, ``prev_action``, and ``prev_prev_action``. Observation terms
+such as ``last_action`` and reward terms such as ``action_rate_l2`` and
+``action_acc_l2`` read from these buffers. Action history is zeroed on
+environment reset so that episode boundaries do not leak information.
+
+
+Multiple action terms
+---------------------
+
+An environment can register any number of terms. The action manager
+concatenates their dimensions in registration order, splits the
+policy's output tensor at the corresponding boundaries, and routes
+each slice independently.
+
+.. code-block:: python
+
+    from mjlab.envs.mdp.actions import (
+        JointPositionActionCfg,
+        JointVelocityActionCfg,
+    )
+
+    actions = {
+        "arm_joints": JointPositionActionCfg(
+            entity_name="robot",
+            actuator_names=(".*_arm_.*",),
+            scale=0.5,
+        ),
+        "wheel_joints": JointVelocityActionCfg(
+            entity_name="robot",
+            actuator_names=(".*_wheel_.*",),
+            scale=10.0,
+        ),
+    }
+
+The policy outputs a tensor whose width equals the total number of
+matched targets across all terms. Terms can also target different
+entities, for example one term for a robot and another for an object
+being manipulated.
diff --git a/docs/source/actuators.rst b/docs/source/actuators.rst
new file mode 100644
index 0000000..4227837
--- /dev/null
+++ b/docs/source/actuators.rst
@@ -0,0 +1,476 @@
+.. _actuators:
+
+Actuators
+=========
+
+Actuators convert high-level commands (position, velocity, effort) into
+low-level efforts that drive joints. They are configured through the
+``articulation`` field of :ref:`EntityCfg <entity>`. mjlab provides
+**built-in** actuators that leverage the physics engine's implicit
+integration for best stability, and **explicit** actuators for custom
+control laws and actuator dynamics.
+
+
+Quick start
+-----------
+
+Basic PD control with ``BuiltinPositionActuator``, the most common
+starting point.
+
+.. code-block:: python
+
+    from mjlab.actuator import BuiltinPositionActuatorCfg
+    from mjlab.entity import EntityCfg, EntityArticulationInfoCfg
+
+    robot_cfg = EntityCfg(
+        spec_fn=lambda: load_robot_spec(),
+        articulation=EntityArticulationInfoCfg(
+            actuators=(
+                BuiltinPositionActuatorCfg(
+                    target_names_expr=(".*_hip_.*", ".*_knee_.*"),
+                    stiffness=80.0,
+                    damping=10.0,
+                    effort_limit=100.0,
+                ),
+            ),
+        ),
+    )
+
+Add delay fields directly on any actuator config to model communication
+latency.
+
+.. code-block:: python
+
+    from mjlab.actuator import BuiltinPositionActuatorCfg
+
+    BuiltinPositionActuatorCfg(
+        target_names_expr=(".*",),
+        stiffness=80.0,
+        damping=10.0,
+        delay_min_lag=2,  # Minimum 2 physics steps
+        delay_max_lag=5,  # Maximum 5 physics steps
+    )
+
+
+Built-in vs explicit actuators
+------------------------------
+
+The key design decision when configuring actuators is whether to use
+**built-in** or **explicit** types. The difference comes down to how
+MuJoCo's integrator handles velocity-dependent forces.
+
+**Built-in actuators** (``BuiltinPositionActuator``,
+``BuiltinVelocityActuator``, ``BuiltinMotorActuator``,
+``BuiltinPdActuator``, ``BuiltinDcMotorActuator``,
+``BuiltinMuscleActuator``) create native MuJoCo actuator elements in the
+MjSpec. The physics engine computes the control law and integrates
+velocity-dependent damping forces implicitly. This provides the best
+numerical stability, particularly with high gains or large timesteps.
+
+**Explicit actuators** (``IdealPdActuator``, ``DcMotorActuator``,
+``LearnedMlpActuator``) compute torques in user code and forward them
+through a ``<motor>`` actuator acting as a passthrough. Because the
+integrator cannot account for the velocity derivatives of these
+externally computed forces, they are less numerically robust than built-in
+types. Use explicit actuators when you need custom control laws or actuator
+dynamics that cannot be expressed with built-in types (e.g.,
+velocity-dependent torque limits, learned actuator networks).
+
+The two approaches match closely in the linear, unconstrained regime at
+small timesteps. At larger timesteps or higher gains, built-in actuators
+are more forgiving.
+
+**Integrator choice.** mjlab places damping inside the actuator rather than
+in joints. The ``euler`` integrator treats joint damping implicitly but
+actuator damping explicitly, limiting stability. The ``implicitfast``
+integrator treats all known velocity-dependent forces implicitly, handling
+both proportional and damping terms of the actuator without additional cost.
+
+.. note::
+
+     mjlab defaults to ``implicitfast``, as it is MuJoCo's recommended
+     integrator and provides superior stability for actuator-side damping.
+
+
+Actuator types
+--------------
+
+All actuator configs share a few common fields inherited from
+``ActuatorCfg``:
+
+- ``target_names_expr``: Tuple of regex patterns matched against joint
+  names (or tendon/site names when using a different
+  ``transmission_type``).
+- ``armature``: Reflected rotor inertia added to the target joint.
+- ``frictionloss``: Static friction (stiction) modeled as a constraint
+  on the target joint. See MuJoCo's
+  `frictionloss <https://mujoco.readthedocs.io/en/stable/XMLreference.html#body-joint-frictionloss>`_.
+
+Built-in actuators
+^^^^^^^^^^^^^^^^^^
+
+Built-in actuators use MuJoCo's native actuator types via the MjSpec API.
+
+**BuiltinPositionActuator**: Creates ``<position>`` actuators for PD
+control.
+
+**BuiltinVelocityActuator**: Creates ``<velocity>`` actuators for velocity
+control.
+
+**BuiltinMotorActuator**: Creates ``<motor>`` actuators for direct torque
+control.
+
+**BuiltinPdActuator**: Native PD that closes on both a position and a
+velocity target, implemented as paired ``<position>`` + ``<velocity>``
+actuators summing to ``kp * (p_target - q) + kd * (v_target - qdot)``.
+``BuiltinPositionActuator`` puts kd on the ``<position>`` element and
+implicitly assumes a zero velocity reference; use this when the policy
+emits a non-zero velocity target. Native delivery lets
+``implicit`` / ``implicitfast`` see the kd term in their velocity update,
+unlike ``IdealPdActuator`` which forwards Python-computed torque through
+an opaque ``<motor>``.
+
+**BuiltinDcMotorActuator**: Wraps MuJoCo's native
+`<dcmotor> <https://mujoco.readthedocs.io/en/stable/XMLreference.html#actuator-dcmotor>`_
+element. Torque is ``tau = K * (V - K * omega) / R``; the back-EMF runs
+through the native bias path, so ``implicit`` / ``implicitfast`` pick up
+its velocity derivative as effective damping. Three input modes pick what
+``ctrl`` carries: VOLTAGE drives the motor directly; POSITION / VELOCITY
+close an internal PID (with anti-windup and slew limiting) against a
+single setpoint, whose Vmax-clamped output becomes torque. POSITION mode
+pins v_target = 0 (the kd term acts on raw velocity). Optional physics:
+inductance,
+thermal model with I^2R heating, cogging ripple, LuGre friction.
+``DcMotorActuator`` (the explicit version) is a software PD with a
+velocity-dependent torque clamp on top of a ``<motor>``; this is the real
+electrical model.
+
+**BuiltinMuscleActuator**: Creates ``<muscle>`` actuators for
+biologically-inspired muscle dynamics with force-length-velocity
+characteristics.
+
+.. code-block:: python
+
+    from mjlab.actuator import BuiltinPositionActuatorCfg, BuiltinVelocityActuatorCfg
+
+    # Mobile manipulator: PD for arm joints, velocity control for wheels.
+    actuators = (
+        BuiltinPositionActuatorCfg(
+            target_names_expr=(".*_shoulder_.*", ".*_elbow_.*", ".*_wrist_.*"),
+            stiffness=100.0,
+            damping=10.0,
+            effort_limit=150.0,
+        ),
+        BuiltinVelocityActuatorCfg(
+            target_names_expr=(".*_wheel_.*",),
+            damping=20.0,
+            effort_limit=50.0,
+        ),
+    )
+
+
+Explicit actuators
+^^^^^^^^^^^^^^^^^^
+
+Explicit actuators compute efforts and forward them to an underlying
+``<motor>`` actuator acting as a passthrough. See
+`Built-in vs explicit actuators`_ above for stability implications.
+
+**IdealPdActuator**: Implements an ideal PD controller. Computes torques
+as ``tau = Kp * pos_error + Kd * vel_error``.
+
+**DcMotorActuator**: Extends ``IdealPdActuator`` with velocity-dependent
+torque saturation to model DC motor torque-speed curves (back-EMF
+effects). Implements a linear torque-speed curve: maximum torque at zero
+velocity, zero torque at maximum velocity.
+
+**LearnedMlpActuator**: Neural network-based actuator that uses a
+trained MLP to predict torque outputs from joint state history. Useful
+when analytical models cannot capture complex actuator dynamics like
+delays, nonlinearities, and friction effects. Inherits DC motor
+velocity-based torque limits.
+
+.. code-block:: python
+
+    from mjlab.actuator import IdealPdActuatorCfg, DcMotorActuatorCfg
+
+    # Ideal PD for hips, DC motor model with torque-speed curve for knees.
+    actuators = (
+        IdealPdActuatorCfg(
+            target_names_expr=(".*_hip_.*",),
+            stiffness=80.0,
+            damping=10.0,
+            effort_limit=100.0,
+        ),
+        DcMotorActuatorCfg(
+            target_names_expr=(".*_knee_.*",),
+            stiffness=80.0,
+            damping=10.0,
+            effort_limit=25.0,       # Continuous torque limit
+            saturation_effort=50.0,  # Peak torque at stall
+            velocity_limit=30.0,     # No-load speed (rad/s)
+        ),
+    )
+
+
+XML actuators
+^^^^^^^^^^^^^
+
+XML actuators wrap actuators already defined in your robot's XML file. The
+config finds existing actuators by matching their ``target`` joint name
+against the ``target_names_expr`` patterns. Each joint must have exactly one
+matching actuator.
+
+**XmlActuator**: Wraps any actuator already defined in the XML. The
+actuator type (position, velocity, motor, muscle) is auto detected from
+the XML element, or you can set ``command_field`` explicitly.
+
+.. code-block:: python
+
+    from mjlab.actuator import XmlActuatorCfg
+
+    # Robot XML already has:
+    # <actuator>
+    #   <position name="hip_joint" joint="hip_joint" kp="100"/>
+    # </actuator>
+
+    # Wrap existing XML actuators.
+    actuators = (
+        XmlActuatorCfg(target_names_expr=("hip_joint",)),
+    )
+
+Actuator delays
+^^^^^^^^^^^^^^^
+
+Any actuator config supports inline delay fields for modeling command
+latency. On a real robot, the onboard PD loop runs at KHz with direct
+encoder access, but the position target from the policy arrives late due
+to inference time and communication bus cycles. Actuator
+delay models this: the command target is delayed, but the control law
+still sees fresh joint state.
+
+This is distinct from observation delay, which models sensor pipeline
+latency (stale state going into the policy). Together they cover both
+legs of the round trip: sensor to policy to motor.
+
+.. code-block:: python
+
+    from mjlab.actuator import IdealPdActuatorCfg
+
+    # Add 2-5 step delay to position commands.
+    actuators = (
+        IdealPdActuatorCfg(
+            target_names_expr=(".*",),
+            stiffness=80.0,
+            damping=10.0,
+            delay_min_lag=2,
+            delay_max_lag=5,
+            delay_hold_prob=0.3,         # 30% chance to keep current lag
+            delay_update_period=10,      # Resample lag every 10 steps
+        ),
+    )
+
+Each step, a lag is sampled uniformly from ``[delay_min_lag,
+delay_max_lag]``. Delays are quantized to physics timesteps. For
+example, with 500Hz physics (2ms/step), ``delay_min_lag=2`` represents
+a 4ms minimum delay.
+
+
+Authoring actuator configs
+--------------------------
+
+Since actuator parameters are uniform within each config, use separate
+actuator configs for joints that need different parameters:
+
+.. code-block:: python
+
+    from mjlab.actuator import BuiltinPositionActuatorCfg
+
+    # G1 humanoid with different gains per joint group.
+    G1_ACTUATORS = (
+        BuiltinPositionActuatorCfg(
+            target_names_expr=(".*_hip_.*", "waist_yaw_joint"),
+            stiffness=180.0,
+            damping=18.0,
+            effort_limit=88.0,
+            armature=0.0015,
+        ),
+        BuiltinPositionActuatorCfg(
+            target_names_expr=("left_hip_pitch_joint", "right_hip_pitch_joint"),
+            stiffness=200.0,
+            damping=20.0,
+            effort_limit=88.0,
+            armature=0.0015,
+        ),
+        BuiltinPositionActuatorCfg(
+            target_names_expr=(".*_knee_joint",),
+            stiffness=150.0,
+            damping=15.0,
+            effort_limit=139.0,
+            armature=0.0025,
+        ),
+        BuiltinPositionActuatorCfg(
+            target_names_expr=(".*_ankle_.*",),
+            stiffness=40.0,
+            damping=5.0,
+            effort_limit=25.0,
+            armature=0.0008,
+        ),
+    )
+
+This design choice reflects a deliberate simplification in mjlab: each
+``ActuatorCfg`` represents a single actuator type (e.g., a specific
+motor/gearbox model) applied uniformly across all joints it drives.
+Hardware parameters such as ``armature`` (reflected rotor inertia) and
+``gear`` describe properties of the actuator hardware, even though they
+are implemented in MuJoCo as joint or actuator fields. In other frameworks
+(like Isaac Lab), these fields may accept ``float | dict[str, float]`` to
+support per-joint variation. mjlab instead encourages one config per
+actuator type or per joint group, keeping the hardware model physically
+consistent and explicit. The main trade-off is verbosity in special cases,
+such as parallel linkages, where per-joint overrides could have been
+convenient, but the benefit is clearer semantics and simpler maintenance.
+
+See :ref:`actions` for how action terms route policy outputs to actuators
+(including DifferentialIK for task-space control), and
+:ref:`domain_randomization` for randomizing gains and effort limits.
+
+
+Computing hardware parameters
+------------------------------
+
+This section is relevant when configuring actuators from real motor
+datasheets. If you are using manually tuned gains, you can skip ahead.
+
+mjlab provides utilities in ``mjlab.utils.actuator`` to compute actuator
+parameters from physical motor specifications. This is particularly
+useful for computing reflected inertia (``armature``) and deriving
+appropriate control gains from hardware datasheets.
+
+**Example: Unitree G1 motor configuration**
+
+.. code-block:: python
+
+    from math import pi
+
+    from mjlab.utils.actuator import (
+        reflected_inertia_from_two_stage_planetary,
+        ElectricActuator
+    )
+
+    # Motor specs from manufacturer datasheet.
+    ROTOR_INERTIAS_7520_14 = (
+        0.489e-4,  # Motor rotor inertia (kg*m**2)
+        0.098e-4,  # Planet carrier inertia
+        0.533e-4,  # Output stage inertia
+    )
+    GEARS_7520_14 = (
+        1,            # First stage (motor to planet)
+        4.5,          # Second stage (planet to carrier)
+        1 + (48/22),  # Third stage (carrier to output)
+    )
+
+    # Compute reflected inertia at joint output.
+    # J_reflected = J_motor*(N1*N2)**2 + J_carrier*N2**2 + J_output.
+    ARMATURE_7520_14 = reflected_inertia_from_two_stage_planetary(
+        ROTOR_INERTIAS_7520_14, GEARS_7520_14
+    )
+
+    # Create motor spec container.
+    ACTUATOR_7520_14 = ElectricActuator(
+        reflected_inertia=ARMATURE_7520_14,
+        velocity_limit=32.0,   # rad/s at joint
+        effort_limit=88.0,     # N*m continuous torque
+    )
+
+    # Derive PD gains from natural frequency and damping ratio.
+    NATURAL_FREQ = 10 * 2*pi  # 10 Hz bandwidth.
+    DAMPING_RATIO = 2.0       # Overdamped, see note below.
+    STIFFNESS = ARMATURE_7520_14 * NATURAL_FREQ**2
+    DAMPING = 2 * DAMPING_RATIO * ARMATURE_7520_14 * NATURAL_FREQ
+
+    # Use in actuator config.
+    from mjlab.actuator import BuiltinPositionActuatorCfg
+
+    actuator = BuiltinPositionActuatorCfg(
+        target_names_expr=(".*_hip_pitch_joint",),
+        stiffness=STIFFNESS,
+        damping=DAMPING,
+        effort_limit=ACTUATOR_7520_14.effort_limit,
+        armature=ACTUATOR_7520_14.reflected_inertia,
+    )
+
+.. note::
+
+     The example uses ``DAMPING_RATIO = 2.0``
+     (overdamped) rather than the critically damped value of 1.0. This is
+     because the reflected inertia calculation only accounts for the motor's
+     rotor inertia, not the apparent inertia of the links being moved. In
+     practice, the total effective inertia at the joint is higher than just
+     the reflected motor inertia, so using an overdamped ratio provides
+     better stability margins when the true system inertia is
+     underestimated.
+
+**Parallel linkage approximation:**
+
+For joints driven by parallel linkages (like the G1's ankles with dual
+motors), the effective armature in the nominal configuration can be
+approximated as the sum of the individual motor armatures:
+
+.. code-block:: python
+
+    # Two 5020 motors driving ankle through parallel linkage.
+    G1_ACTUATOR_ANKLE = BuiltinPositionActuatorCfg(
+        target_names_expr=(".*_ankle_pitch_joint", ".*_ankle_roll_joint"),
+        stiffness=STIFFNESS_5020 * 2,
+        damping=DAMPING_5020 * 2,
+        effort_limit=ACTUATOR_5020.effort_limit * 2,
+        armature=ACTUATOR_5020.reflected_inertia * 2,
+    )
+
+
+Extending: custom actuators
+----------------------------
+
+All actuators implement a unified ``compute()`` interface that receives an
+``ActuatorCmd`` (containing position, velocity, and effort targets) and
+returns control signals for the low-level MuJoCo actuators driving each
+joint.
+
+**Core interface:**
+
+.. code-block:: python
+
+    def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+        """Convert high-level commands to control signals.
+
+        Args:
+            cmd: Command containing position_target, velocity_target,
+                effort_target (each is a [num_envs, num_targets] tensor
+                or None)
+
+        Returns:
+            Control signals for this actuator
+            ([num_envs, num_targets] tensor)
+        """
+
+**Lifecycle hooks:**
+
+- ``edit_spec``: Modify MjSpec before compilation (add actuators, set
+  gains)
+- ``initialize``: Post-compilation setup (resolve indices, allocate
+  buffers)
+- ``reset``: Per-environment reset logic
+- ``update``: Pre-step updates
+- ``compute``: Convert commands to control signals
+
+**Properties:**
+
+- ``target_ids``: Tensor of local target indices controlled by this
+  actuator
+- ``target_names``: List of target names controlled by this actuator
+- ``ctrl_ids``: Tensor of global control input indices for this actuator
+
+``IdealPdActuator`` is the recommended base class for custom explicit
+actuators. ``DcMotorActuator`` and ``LearnedMlpActuator`` are both
+built on top of it and serve as examples of the extension pattern.
diff --git a/docs/source/api/actuator.rst b/docs/source/api/actuator.rst
new file mode 100644
index 0000000..f89063b
--- /dev/null
+++ b/docs/source/api/actuator.rst
@@ -0,0 +1,182 @@
+mjlab.actuator
+==============
+
+.. automodule:: mjlab.actuator
+
+.. rubric:: Classes
+
+.. hlist::
+  :columns: 3
+
+  - :class:`Actuator`
+  - :class:`ActuatorCfg`
+  - :class:`ActuatorCmd`
+  - :class:`BuiltinActuatorGroup`
+  - :class:`BuiltinMotorActuator`
+  - :class:`BuiltinMotorActuatorCfg`
+  - :class:`BuiltinPositionActuator`
+  - :class:`BuiltinPositionActuatorCfg`
+  - :class:`BuiltinVelocityActuator`
+  - :class:`BuiltinVelocityActuatorCfg`
+  - :class:`BuiltinPdActuator`
+  - :class:`BuiltinPdActuatorCfg`
+  - :class:`BuiltinDcMotorActuator`
+  - :class:`BuiltinDcMotorActuatorCfg`
+  - :class:`DcMotorInputMode`
+  - :class:`DcMotorDatasheetParams`
+  - :class:`DcMotorPhysicalParams`
+  - :class:`BuiltinMuscleActuator`
+  - :class:`BuiltinMuscleActuatorCfg`
+  - :class:`XmlActuator`
+  - :class:`XmlActuatorCfg`
+  - :class:`IdealPdActuator`
+  - :class:`IdealPdActuatorCfg`
+  - :class:`DcMotorActuator`
+  - :class:`DcMotorActuatorCfg`
+  - :class:`LearnedMlpActuator`
+  - :class:`LearnedMlpActuatorCfg`
+
+Base
+----
+
+.. autoclass:: Actuator
+  :members:
+  :show-inheritance:
+
+.. autoclass:: ActuatorCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: ActuatorCmd
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+Builtin Actuators
+-----------------
+
+.. autoclass:: BuiltinActuatorGroup
+  :members:
+  :show-inheritance:
+
+.. autoclass:: BuiltinMotorActuator
+  :members:
+  :show-inheritance:
+
+.. autoclass:: BuiltinMotorActuatorCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: BuiltinPositionActuator
+  :members:
+  :show-inheritance:
+
+.. autoclass:: BuiltinPositionActuatorCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: BuiltinVelocityActuator
+  :members:
+  :show-inheritance:
+
+.. autoclass:: BuiltinVelocityActuatorCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: BuiltinPdActuator
+  :members:
+  :show-inheritance:
+
+.. autoclass:: BuiltinPdActuatorCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: BuiltinDcMotorActuator
+  :members:
+  :show-inheritance:
+
+.. autoclass:: BuiltinDcMotorActuatorCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+.. autoclass:: DcMotorInputMode
+  :members:
+  :show-inheritance:
+
+.. autoclass:: DcMotorDatasheetParams
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+.. autoclass:: DcMotorPhysicalParams
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: BuiltinMuscleActuator
+  :members:
+  :show-inheritance:
+
+.. autoclass:: BuiltinMuscleActuatorCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+XML Actuators
+-------------
+
+.. autoclass:: XmlActuator
+  :members:
+  :show-inheritance:
+
+.. autoclass:: XmlActuatorCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+Ideal PD Actuator
+-----------------
+
+.. autoclass:: IdealPdActuator
+  :members:
+  :show-inheritance:
+
+.. autoclass:: IdealPdActuatorCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+DC Motor Actuator
+-----------------
+
+.. autoclass:: DcMotorActuator
+  :members:
+  :show-inheritance:
+
+.. autoclass:: DcMotorActuatorCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+Learned MLP Actuator
+--------------------
+
+.. autoclass:: LearnedMlpActuator
+  :members:
+  :show-inheritance:
+
+.. autoclass:: LearnedMlpActuatorCfg
+  :members:
+  :exclude-members: __init__
diff --git a/docs/source/api/entity.rst b/docs/source/api/entity.rst
new file mode 100644
index 0000000..d6e6e5d
--- /dev/null
+++ b/docs/source/api/entity.rst
@@ -0,0 +1,45 @@
+mjlab.entity
+============
+
+.. automodule:: mjlab.entity
+
+.. rubric:: Classes
+
+.. hlist::
+  :columns: 3
+
+  - :class:`Entity`
+  - :class:`EntityCfg`
+  - :class:`EntityArticulationInfoCfg`
+  - :class:`EntityIndexing`
+  - :class:`EntityData`
+
+Entity
+------
+
+.. autoclass:: Entity
+  :members:
+  :show-inheritance:
+
+.. autoclass:: EntityCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: EntityArticulationInfoCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+EntityIndexing
+--------------
+
+.. autoclass:: EntityIndexing
+  :members:
+
+EntityData
+----------
+
+.. autoclass:: EntityData
+  :members:
diff --git a/docs/source/api/envs.rst b/docs/source/api/envs.rst
new file mode 100644
index 0000000..4dc4257
--- /dev/null
+++ b/docs/source/api/envs.rst
@@ -0,0 +1,36 @@
+mjlab.envs
+==========
+
+.. automodule:: mjlab.envs
+
+.. rubric:: Classes
+
+.. hlist::
+  :columns: 3
+
+  - :class:`ManagerBasedRlEnv`
+  - :class:`ManagerBasedRlEnvCfg`
+  - :data:`VecEnvObs`
+  - :data:`VecEnvStepReturn`
+
+ManagerBasedRlEnv
+-----------------
+
+.. autoclass:: ManagerBasedRlEnv
+  :members:
+  :show-inheritance:
+
+.. autoclass:: ManagerBasedRlEnvCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+VecEnvObs
+---------
+
+.. autodata:: VecEnvObs
+
+VecEnvStepReturn
+----------------
+
+.. autodata:: VecEnvStepReturn
diff --git a/docs/source/api/index.rst b/docs/source/api/index.rst
new file mode 100644
index 0000000..9db9efb
--- /dev/null
+++ b/docs/source/api/index.rst
@@ -0,0 +1,19 @@
+API Reference
+=============
+
+This section provides detailed API documentation for all public modules in mjlab.
+
+.. toctree::
+   :maxdepth: 1
+
+   envs
+   scene
+   sim
+   entity
+   actuator
+   sensor
+   managers
+   terrains
+   rl
+   viewer
+   tasks
diff --git a/docs/source/api/managers.rst b/docs/source/api/managers.rst
new file mode 100644
index 0000000..8852919
--- /dev/null
+++ b/docs/source/api/managers.rst
@@ -0,0 +1,208 @@
+mjlab.managers
+==============
+
+.. automodule:: mjlab.managers
+
+.. rubric:: Classes
+
+.. hlist::
+  :columns: 3
+
+  - :class:`ManagerBase`
+  - :class:`ManagerTermBase`
+  - :class:`ManagerTermBaseCfg`
+  - :class:`SceneEntityCfg`
+  - :class:`ActionManager`
+  - :class:`ActionTerm`
+  - :class:`ActionTermCfg`
+  - :class:`ObservationManager`
+  - :class:`ObservationGroupCfg`
+  - :class:`ObservationTermCfg`
+  - :class:`RewardManager`
+  - :class:`RewardTermCfg`
+  - :class:`TerminationManager`
+  - :class:`TerminationTermCfg`
+  - :class:`CommandManager`
+  - :class:`NullCommandManager`
+  - :class:`CommandTerm`
+  - :class:`CommandTermCfg`
+  - :class:`CurriculumManager`
+  - :class:`NullCurriculumManager`
+  - :class:`CurriculumTermCfg`
+  - :class:`EventManager`
+  - :class:`EventMode`
+  - :class:`EventTermCfg`
+  - :class:`MetricsManager`
+  - :class:`NullMetricsManager`
+  - :class:`MetricsTermCfg`
+  - :class:`RecorderManager`
+  - :class:`NullRecorderManager`
+  - :class:`RecorderTerm`
+  - :class:`RecorderTermCfg`
+
+Base
+----
+
+.. autoclass:: ManagerBase
+  :members:
+  :show-inheritance:
+
+.. autoclass:: ManagerTermBase
+  :members:
+  :show-inheritance:
+
+.. autoclass:: ManagerTermBaseCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: SceneEntityCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+Action Manager
+--------------
+
+.. autoclass:: ActionManager
+  :members:
+  :show-inheritance:
+
+.. autoclass:: ActionTerm
+  :members:
+  :show-inheritance:
+
+.. autoclass:: ActionTermCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+Observation Manager
+-------------------
+
+.. autoclass:: ObservationManager
+  :members:
+  :show-inheritance:
+
+.. autoclass:: ObservationGroupCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: ObservationTermCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+Reward Manager
+--------------
+
+.. autoclass:: RewardManager
+  :members:
+  :show-inheritance:
+
+.. autoclass:: RewardTermCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+Termination Manager
+-------------------
+
+.. autoclass:: TerminationManager
+  :members:
+  :show-inheritance:
+
+.. autoclass:: TerminationTermCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+Command Manager
+---------------
+
+.. autoclass:: CommandManager
+  :members:
+  :show-inheritance:
+
+.. autoclass:: NullCommandManager
+  :members:
+  :show-inheritance:
+
+.. autoclass:: CommandTerm
+  :members:
+  :show-inheritance:
+
+.. autoclass:: CommandTermCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+Curriculum Manager
+------------------
+
+.. autoclass:: CurriculumManager
+  :members:
+  :show-inheritance:
+
+.. autoclass:: NullCurriculumManager
+  :members:
+  :show-inheritance:
+
+.. autoclass:: CurriculumTermCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+Event Manager
+-------------
+
+.. autoclass:: EventManager
+  :members:
+  :show-inheritance:
+
+.. autoclass:: EventMode
+  :members:
+  :undoc-members:
+
+.. autoclass:: EventTermCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+Metrics Manager
+---------------
+
+.. autoclass:: MetricsManager
+  :members:
+  :show-inheritance:
+
+.. autoclass:: NullMetricsManager
+  :members:
+  :show-inheritance:
+
+.. autoclass:: MetricsTermCfg
+  :members:
+  :exclude-members: __init__
+
+Recorder Manager
+----------------
+
+.. autoclass:: RecorderManager
+  :members:
+  :show-inheritance:
+
+.. autoclass:: NullRecorderManager
+  :members:
+  :show-inheritance:
+
+.. autoclass:: RecorderTerm
+  :members:
+  :show-inheritance:
+
+.. autoclass:: RecorderTermCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
diff --git a/docs/source/api/rl.rst b/docs/source/api/rl.rst
new file mode 100644
index 0000000..2f173a3
--- /dev/null
+++ b/docs/source/api/rl.rst
@@ -0,0 +1,52 @@
+mjlab.rl
+========
+
+.. automodule:: mjlab.rl
+
+.. rubric:: Classes
+
+.. hlist::
+  :columns: 3
+
+  - :class:`MjlabOnPolicyRunner`
+  - :class:`RslRlVecEnvWrapper`
+  - :class:`RslRlOnPolicyRunnerCfg`
+  - :class:`RslRlPpoAlgorithmCfg`
+  - :class:`RslRlModelCfg`
+  - :class:`RslRlBaseRunnerCfg`
+
+Runner
+------
+
+.. autoclass:: MjlabOnPolicyRunner
+  :members:
+  :show-inheritance:
+
+.. autoclass:: RslRlVecEnvWrapper
+  :members:
+  :show-inheritance:
+
+Configuration
+-------------
+
+.. autoclass:: RslRlOnPolicyRunnerCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: RslRlPpoAlgorithmCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: RslRlModelCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: RslRlBaseRunnerCfg
+  :members:
+  :exclude-members: __init__
diff --git a/docs/source/api/scene.rst b/docs/source/api/scene.rst
new file mode 100644
index 0000000..5d5f983
--- /dev/null
+++ b/docs/source/api/scene.rst
@@ -0,0 +1,23 @@
+mjlab.scene
+===========
+
+.. automodule:: mjlab.scene
+
+.. rubric:: Classes
+
+.. hlist::
+  :columns: 3
+
+  - :class:`Scene`
+  - :class:`SceneCfg`
+
+Scene
+-----
+
+.. autoclass:: Scene
+  :members:
+
+.. autoclass:: SceneCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
diff --git a/docs/source/api/sensor.rst b/docs/source/api/sensor.rst
new file mode 100644
index 0000000..70edd71
--- /dev/null
+++ b/docs/source/api/sensor.rst
@@ -0,0 +1,126 @@
+mjlab.sensor
+============
+
+.. automodule:: mjlab.sensor
+
+.. rubric:: Classes
+
+.. hlist::
+  :columns: 3
+
+  - :class:`Sensor`
+  - :class:`SensorCfg`
+  - :class:`SensorContext`
+  - :class:`BuiltinSensor`
+  - :class:`BuiltinSensorCfg`
+  - :class:`ObjRef`
+  - :class:`ContactSensor`
+  - :class:`ContactSensorCfg`
+  - :class:`ContactData`
+  - :class:`ContactMatch`
+  - :class:`RayCastSensor`
+  - :class:`RayCastSensorCfg`
+  - :class:`RayCastData`
+  - :class:`GridPatternCfg`
+  - :class:`PinholeCameraPatternCfg`
+  - :class:`CameraSensor`
+  - :class:`CameraSensorCfg`
+  - :class:`CameraSensorData`
+
+Base
+----
+
+.. autoclass:: Sensor
+  :members:
+  :show-inheritance:
+
+.. autoclass:: SensorCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: SensorContext
+  :members:
+
+Builtin Sensor
+--------------
+
+.. autoclass:: BuiltinSensor
+  :members:
+  :show-inheritance:
+
+.. autoclass:: BuiltinSensorCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: ObjRef
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+Contact Sensor
+--------------
+
+.. autoclass:: ContactSensor
+  :members:
+  :show-inheritance:
+
+.. autoclass:: ContactSensorCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: ContactData
+  :members:
+
+.. autoclass:: ContactMatch
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+Ray Cast Sensor
+---------------
+
+.. autoclass:: RayCastSensor
+  :members:
+  :show-inheritance:
+
+.. autoclass:: RayCastSensorCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: RayCastData
+  :members:
+
+.. autoclass:: GridPatternCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: PinholeCameraPatternCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+Camera Sensor
+-------------
+
+.. autoclass:: CameraSensor
+  :members:
+  :show-inheritance:
+
+.. autoclass:: CameraSensorCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: CameraSensorData
+  :members:
diff --git a/docs/source/api/sim.rst b/docs/source/api/sim.rst
new file mode 100644
index 0000000..f3faa6b
--- /dev/null
+++ b/docs/source/api/sim.rst
@@ -0,0 +1,44 @@
+mjlab.sim
+=========
+
+.. automodule:: mjlab.sim
+
+.. rubric:: Classes
+
+.. hlist::
+  :columns: 3
+
+  - :class:`Simulation`
+  - :class:`SimulationCfg`
+  - :class:`MujocoCfg`
+  - :class:`TorchArray`
+  - :class:`WarpBridge`
+
+Simulation
+----------
+
+.. autoclass:: Simulation
+  :members:
+
+.. autoclass:: SimulationCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: MujocoCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+TorchArray
+----------
+
+.. autoclass:: TorchArray
+  :members:
+
+WarpBridge
+----------
+
+.. autoclass:: WarpBridge
+  :members:
diff --git a/docs/source/api/tasks.rst b/docs/source/api/tasks.rst
new file mode 100644
index 0000000..4b9dd8b
--- /dev/null
+++ b/docs/source/api/tasks.rst
@@ -0,0 +1,25 @@
+mjlab.tasks
+===========
+
+.. automodule:: mjlab.tasks.registry
+
+.. rubric:: Functions
+
+.. hlist::
+  :columns: 3
+
+  - :func:`register_mjlab_task`
+  - :func:`list_tasks`
+  - :func:`load_env_cfg`
+  - :func:`load_rl_cfg`
+  - :func:`load_runner_cls`
+
+.. autofunction:: register_mjlab_task
+
+.. autofunction:: list_tasks
+
+.. autofunction:: load_env_cfg
+
+.. autofunction:: load_rl_cfg
+
+.. autofunction:: load_runner_cls
diff --git a/docs/source/api/terrains.rst b/docs/source/api/terrains.rst
new file mode 100644
index 0000000..976e394
--- /dev/null
+++ b/docs/source/api/terrains.rst
@@ -0,0 +1,167 @@
+mjlab.terrains
+==============
+
+.. automodule:: mjlab.terrains
+
+.. rubric:: Classes
+
+.. hlist::
+  :columns: 3
+
+  - :class:`TerrainEntity`
+  - :class:`TerrainEntityCfg`
+  - :class:`TerrainGenerator`
+  - :class:`TerrainGeneratorCfg`
+  - :class:`SubTerrainCfg`
+  - :class:`FlatPatchSamplingCfg`
+  - :class:`HfDiscreteObstaclesTerrainCfg`
+  - :class:`HfPerlinNoiseTerrainCfg`
+  - :class:`HfPyramidSlopedTerrainCfg`
+  - :class:`HfRandomUniformTerrainCfg`
+  - :class:`HfWaveTerrainCfg`
+  - :class:`BoxFlatTerrainCfg`
+  - :class:`BoxInvertedPyramidStairsTerrainCfg`
+  - :class:`BoxNarrowBeamsTerrainCfg`
+  - :class:`BoxNestedRingsTerrainCfg`
+  - :class:`BoxOpenStairsTerrainCfg`
+  - :class:`BoxPyramidStairsTerrainCfg`
+  - :class:`BoxRandomGridTerrainCfg`
+  - :class:`BoxRandomSpreadTerrainCfg`
+  - :class:`BoxRandomStairsTerrainCfg`
+  - :class:`BoxSteppingStonesTerrainCfg`
+  - :class:`BoxTiltedGridTerrainCfg`
+
+Core
+----
+
+.. autoclass:: TerrainEntity
+  :members:
+  :show-inheritance:
+
+.. autoclass:: TerrainEntityCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: TerrainGenerator
+  :members:
+
+.. autoclass:: TerrainGeneratorCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: SubTerrainCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+
+.. autoclass:: FlatPatchSamplingCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+Heightfield Terrains
+--------------------
+
+.. autoclass:: HfDiscreteObstaclesTerrainCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+  :show-inheritance:
+
+.. autoclass:: HfPerlinNoiseTerrainCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+  :show-inheritance:
+
+.. autoclass:: HfRandomUniformTerrainCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+  :show-inheritance:
+
+.. autoclass:: HfPyramidSlopedTerrainCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+  :show-inheritance:
+
+.. autoclass:: HfWaveTerrainCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+  :show-inheritance:
+
+Primitive (Box) Terrains
+------------------------
+
+.. autoclass:: BoxFlatTerrainCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+  :show-inheritance:
+
+.. autoclass:: BoxInvertedPyramidStairsTerrainCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+  :show-inheritance:
+
+.. autoclass:: BoxNarrowBeamsTerrainCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+  :show-inheritance:
+
+.. autoclass:: BoxNestedRingsTerrainCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+  :show-inheritance:
+
+.. autoclass:: BoxOpenStairsTerrainCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+  :show-inheritance:
+
+.. autoclass:: BoxPyramidStairsTerrainCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+  :show-inheritance:
+
+.. autoclass:: BoxRandomGridTerrainCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+  :show-inheritance:
+
+.. autoclass:: BoxRandomSpreadTerrainCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+  :show-inheritance:
+
+.. autoclass:: BoxRandomStairsTerrainCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+  :show-inheritance:
+
+.. autoclass:: BoxSteppingStonesTerrainCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+  :show-inheritance:
+
+.. autoclass:: BoxTiltedGridTerrainCfg
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+  :show-inheritance:
diff --git a/docs/source/api/viewer.rst b/docs/source/api/viewer.rst
new file mode 100644
index 0000000..21c6570
--- /dev/null
+++ b/docs/source/api/viewer.rst
@@ -0,0 +1,72 @@
+mjlab.viewer
+============
+
+.. automodule:: mjlab.viewer
+
+.. rubric:: Classes
+
+.. hlist::
+  :columns: 3
+
+  - :class:`ViewerConfig`
+  - :class:`BaseViewer`
+  - :class:`NativeMujocoViewer`
+  - :class:`ViserPlayViewer`
+  - :class:`OffscreenRenderer`
+
+.. rubric:: Protocols
+
+.. hlist::
+  :columns: 3
+
+  - :class:`EnvProtocol`
+  - :class:`PolicyProtocol`
+  - :class:`VerbosityLevel`
+
+ViewerConfig
+------------
+
+.. autoclass:: ViewerConfig
+  :members:
+  :exclude-members: __init__
+  :undoc-members:
+
+BaseViewer
+----------
+
+.. autoclass:: BaseViewer
+  :members:
+  :show-inheritance:
+
+NativeMujocoViewer
+------------------
+
+.. autoclass:: NativeMujocoViewer
+  :members:
+  :show-inheritance:
+
+ViserPlayViewer
+---------------
+
+.. autoclass:: ViserPlayViewer
+  :members:
+  :show-inheritance:
+
+OffscreenRenderer
+-----------------
+
+.. autoclass:: OffscreenRenderer
+  :members:
+  :show-inheritance:
+
+Protocols
+---------
+
+.. autoclass:: EnvProtocol
+  :members:
+
+.. autoclass:: PolicyProtocol
+  :members:
+
+.. autoclass:: VerbosityLevel
+  :members:
diff --git a/docs/source/architecture_overview.rst b/docs/source/architecture_overview.rst
new file mode 100644
index 0000000..ea5dd12
--- /dev/null
+++ b/docs/source/architecture_overview.rst
@@ -0,0 +1,192 @@
+.. _architecture_overview:
+
+Architecture Overview
+=====================
+
+mjlab is organized into two layers: a **simulation layer** that models
+the robot and world, and a **manager layer** that defines the
+reinforcement learning problem on top of it. Understanding this separation
+is the fastest way to build a mental map of the system.
+
+.. figure:: _static/architecture_diagram.png
+   :width: 60%
+   :align: center
+   :alt: mjlab architecture diagram
+
+   Entities are composed into an MjSpec, compiled, and transferred to
+   MuJoCo Warp for GPU simulation. The ManagerBasedRlEnv orchestrates the
+   MDP; RSL-RL handles training.
+
+
+The simulation layer
+--------------------
+
+**Scene pipeline.**
+mjlab constructs scenes by composing entity descriptions into a single
+`MjSpec <https://mujoco.readthedocs.io/en/stable/programming/modeledit.html>`_.
+Each entity starts from an
+`MJCF <https://mujoco.readthedocs.io/en/latest/modeling.html>`_ file
+loaded via ``MjSpec.from_file()``. Users who define everything in XML can
+use this directly. For more control, Python dataclasses can extend or
+override properties on the loaded spec: actuators, collision rules,
+materials, sensors, and initial state. This hybrid approach lets users
+start from existing MuJoCo models and layer on task-specific configuration
+without modifying the original XML. The composed specification is compiled
+into an ``MjModel`` on the CPU, then transferred to the GPU via
+`MuJoCo Warp <https://mujoco.readthedocs.io/en/stable/mjwarp/index.html>`_,
+which is built on `NVIDIA Warp <https://nvidia.github.io/warp/>`_.
+
+**MuJoCo Warp.**
+MuJoCo Warp is a GPU-accelerated backend for MuJoCo. It preserves
+MuJoCo's ``MjModel``/``MjData`` paradigm but adds a leading *world*
+dimension: a single ``MjData`` object holds the state of N independent
+simulation instances in parallel, enabling thousands of environments to
+be stepped simultaneously. Model parameters are shared across all worlds
+by default, and individual fields can be expanded to vary per-world when
+domain randomization requires it. mjlab captures the simulation step as a
+`CUDA graph <https://developer.nvidia.com/blog/cuda-graphs>`_: the kernel
+execution sequence is recorded once and replayed on subsequent calls,
+eliminating CPU-side dispatch overhead.
+
+.. note::
+
+   CUDA graph capture is a one-time cost at environment startup. Per-episode
+   resets and domain randomization events run as regular Python between graph
+   replays and do not break the capture.
+
+**Components.**
+The simulation layer provides four core components, each with its own
+documentation page:
+
+- :ref:`entity`: a robot, a manipulated object, or a static object such
+  as :ref:`terrain <terrain>`, defined by an MJCF description plus
+  optional Python configuration for actuators, collision rules, and
+  initial state.
+- :ref:`actuators`: how entities are controlled. Users can wrap actuators
+  already defined in MJCF or create new ones from Python configuration.
+- :ref:`sensors`: how the world is observed. Includes MuJoCo-native
+  sensors as well as custom sensors like RGB-D cameras and raycasters.
+- :ref:`scene`: scene composition and environment placement.
+
+
+The manager layer
+-----------------
+
+On top of the simulation layer, mjlab adopts the manager-based environment
+design introduced by Isaac Lab. Users define their environment by composing
+small, self-contained *terms* (reward functions, observation computations,
+domain randomization events) and register them with the appropriate manager.
+Each manager handles the lifecycle of its terms: calling them at the right
+point in the simulation loop, aggregating their outputs, and exposing
+diagnostics.
+
+Terms can be plain functions for stateless computations, or classes that
+inherit from ``ManagerTermBase`` when they need to cache expensive setup
+(such as resolving regex patterns to joint indices at initialization) or
+maintain per-episode state through a ``reset()`` hook.
+
+Environments are configured through ``ManagerBasedRlEnvCfg``, a plain
+dataclass that holds term configuration dictionaries for each manager.
+
+.. code-block:: python
+
+    from mjlab.envs import ManagerBasedRlEnvCfg
+
+    cfg = ManagerBasedRlEnvCfg(
+        decimation=4,           # 4 physics steps per policy step
+        episode_length_s=20.0,
+        scene=...,              # SceneCfg: terrain, entities, sensors
+        sim=...,                # SimulationCfg: timestep, solver, integrator
+        observations={...},     # ObservationManager terms
+        actions={...},          # ActionManager terms
+        rewards={...},          # RewardManager terms
+        terminations={...},     # TerminationManager terms
+        events={...},           # EventManager terms (resets, DR)
+        commands={...},         # CommandManager terms (velocity targets, etc.)
+        curriculum={...},       # CurriculumManager terms
+        metrics={...},          # MetricsManager terms
+    )
+
+.. rubric:: The eight managers
+
+- **ObservationManager**: assembles observation groups with configurable
+  processing (clipping, noise, delay, history). Supports asymmetric
+  actor-critic. See :ref:`observations`.
+- **ActionManager**: routes the policy's output tensor to entity actuators,
+  handling scaling and offset. See :ref:`actions`.
+- **RewardManager**: computes a weighted sum of reward terms, scaled by step
+  duration for frequency invariance. See :ref:`rewards`.
+- **TerminationManager**: evaluates stop conditions, distinguishing terminal
+  resets from timeouts. See :ref:`terminations`.
+- **EventManager**: fires terms at lifecycle points (startup, reset,
+  interval). Domain randomization is implemented through event terms.
+  See :ref:`events` and :ref:`domain_randomization`.
+- **CommandManager**: generates and resamples goal signals (velocity
+  targets, pose targets). See :ref:`commands`.
+- **CurriculumManager**: adjusts training conditions based on policy
+  performance. See :ref:`curriculum`.
+- **MetricsManager**: logs custom per-step values as episode averages.
+  See :ref:`metrics`.
+
+For the full configuration reference covering all managers, see
+:ref:`environment_config`.
+
+
+The environment lifecycle
+-------------------------
+
+Each environment instance passes through four phases.
+
+1. **Build.** ``Scene`` composes entity MJCF files via ``MjSpec`` and
+   compiles ``MjModel`` on the CPU. ``Simulation`` uploads the model to the
+   GPU via MuJoCo Warp, allocating a single ``MjData`` with N parallel
+   worlds. CUDA graphs for ``step``, ``forward``, ``reset``, and ``sense``
+   are captured.
+
+2. **Initialize.** Managers are constructed from the term configuration
+   dictionaries. Regex patterns are matched to joint, body, and geom
+   indices. Observation history and delay buffers are allocated. Model
+   fields required by domain randomization terms are expanded from shared
+   to per-world storage, and CUDA graphs are rebuilt to reflect the new
+   layout. Startup events are fired once.
+
+3. **Reset.** Called at the start of training and whenever an environment
+   terminates or times out. The ``EventManager`` fires ``reset`` terms,
+   which return the scene to an initial state with optional randomization.
+   Command targets are resampled. Observation history buffers are cleared.
+
+4. **Step.** The policy action is processed by the ``ActionManager``. The
+   physics simulation advances ``decimation`` times, with actuator commands
+   applied and entity state updated each sub-step. After the decimation
+   loop, the ``TerminationManager`` checks stop conditions and the
+   ``RewardManager`` computes the reward signal. Step and interval events
+   fire if scheduled, acting on the pre-reset state. Any terminated
+   environments are then reset. A single ``forward()`` call refreshes
+   derived quantities for all environments. The ``CommandManager`` advances
+   or resamples goals. Sensors update. The ``ObservationManager`` assembles
+   the observation for the next policy query.
+
+The step sequence in order:
+
+.. code-block:: text
+
+    action_manager.process_action(action)
+    for _ in range(decimation):
+        action_manager.apply_action()
+        sim.step()
+        scene.update()
+    termination_manager.compute()
+    reward_manager.compute()
+    metrics_manager.compute()
+    event_manager.apply(mode="step")
+    event_manager.apply(mode="interval")
+    [reset terminated envs]
+    sim.forward()
+    command_manager.compute()  # dt=0 for envs just reset
+    sim.sense()
+    observation_manager.compute()
+
+With this mental model in place, the Concepts pages cover each simulation
+layer component in detail, and The Manager Layer pages walk through each
+manager's configuration and built-in terms. If you are coming from Isaac
+Lab, :ref:`migration_isaac_lab` describes the key API differences.
diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
new file mode 100644
index 0000000..0b8b643
--- /dev/null
+++ b/docs/source/changelog.rst
@@ -0,0 +1,1044 @@
+=========
+Changelog
+=========
+
+Upcoming version (not yet released)
+-----------------------------------
+
+Changed
+^^^^^^^
+
+- Bumped ``rsl-rl-lib`` from 5.4.2 to 5.5.0. This update removes the ``logger_type``
+  attribute of the ``rsl_rl.utils.Logger``, so code that previously checked
+  ``logger.logger_type`` must instead check the type of ``logger.writer``.
+
+Version 1.6.0 (August 8, 2026)
+------------------------------
+
+.. admonition:: Breaking API changes
+   :class: attention
+
+   - ``CollisionCfg`` now requires ``contype``, ``conaffinity``, ``condim``,
+     and ``priority`` to be explicit instead of silently defaulting to
+     MuJoCo's values, and dict values for these fields must cover every
+     matched geom (add a catch-all ``".*"`` entry).
+   - ``CommandTerm._update_command`` now takes an ``env_ids`` argument:
+     ``None`` on the regular per-step update and the reset environment ids
+     when called from ``reset()``. Custom command terms must add the
+     parameter (construction raises a ``TypeError`` with migration
+     instructions otherwise) and scope any per-step state advance, such as
+     a motion frame index, to ``env_ids``.
+   - ``ViewerConfig`` is now keyword-only; positional construction no
+     longer works.
+
+.. admonition:: Highlights
+   :class: note
+
+   - Upgraded to MuJoCo and MuJoCo Warp 3.11.
+   - Upgraded ``rsl-rl-lib`` to 5.4.2.
+
+Added
+^^^^^
+
+- Added ``GeomCfg``, exposed as the ``geoms`` field on ``EntityCfg``, a spec
+  editor that matches geoms by name and patches their attributes. Supports
+  ``group`` (so a geom can collide without being drawn) and all collision
+  attributes; unset attributes are left untouched. Contribution by
+  @bd-pmorais.
+- Added ``diffuse``, ``specular``, ``ambient``, ``active``, and
+  ``attenuation`` fields to ``LightCfg`` for configuring light color and
+  falloff. Contribution by @bd-pmorais.
+- Added ``random``, ``file``, ``cubefiles``, ``gridsize``, ``gridlayout``,
+  ``nchannel``, ``hflip``, and ``vflip`` fields to ``TextureCfg``, so textures
+  can be loaded from image files instead of only built-in patterns.
+  ``width`` and ``height`` are now optional, since file-based textures take
+  their size from the image. Contribution by @bd-pmorais.
+- Added light domain randomization functions: ``dr.light_diffuse``,
+  ``dr.light_specular``, ``dr.light_ambient``, ``dr.light_attenuation``,
+  ``dr.light_cutoff``, and ``dr.light_exponent``. Contribution by @bd-pmorais.
+- Added ``reduce="sum"`` to ``MetricsTermCfg`` for reporting the accumulated
+  episode total (e.g. episodic reward, total distance traveled) instead of a
+  per-step average. Contribution by @bd-mlutter
+- Added ``ViewerConfig.geom_group`` and ``ViewerConfig.site_group`` to
+  control which geom and site visualization groups the offscreen renderer
+  draws. Defaults match MuJoCo's (groups 0 through 2), so rendering is
+  unchanged unless configured. Contribution by @bd-mlutter.
+- Added ``dr.mat_texid`` to randomize which texture fills a given
+  ``mjtTextureRole`` slot (RGB by default) of each selected material,
+  sampling uniformly from ``asset_cfg.texture_names``. Contribution by
+  @bd-pmorais.
+
+.. figure:: _static/changelog/mat_texid_dr.gif
+   :width: 30%
+
+Changed
+^^^^^^^
+
+- Bumped ``mujoco`` and ``mujoco-warp`` from 3.10 to 3.11, and regenerated the
+  bundled MuJoCo type stubs.
+- Bumped ``rsl-rl-lib`` from 5.4.0 to 5.4.2.
+- ``CollisionCfg`` and ``GeomCfg`` now share one write path, and mjlab warns
+  when a ``GeomCfg`` collision patch is overwritten by a ``CollisionCfg``.
+- Changed the default MuJoCo Warp render background to solid black
+  (``0, 0, 0, 1``), matching MuJoCo's native renderer. Contribution by
+  @bd-pmorais.
+- The offscreen renderer now works on a copy of the ``MjModel``, so its
+  render-only tweaks (extent, shadows, reflections, offscreen size) no
+  longer leak into the shared model. Contribution by @bd-mlutter.
+- ``ViewerConfig`` is now keyword-only, with fields grouped and documented.
+  Contribution by @bd-mlutter.
+- ``ViewerConfig.fovy`` now also applies to the ``ASSET_ROOT`` and
+  ``ASSET_BODY`` tracking cameras instead of being silently ignored; leave
+  it at ``None`` (the default) to keep the model value. Contribution by
+  @bd-mlutter.
+- ``auto_reset`` and an explicit ``reset()`` now leave identical command and
+  event timer state (:issue:`1133`).
+
+Fixed
+^^^^^
+
+- The Viser motion scrubber's Start Here button no longer computes relative
+  body poses from stale pre-scrub kinematics, which could spuriously
+  terminate the episode on the next step.
+- Mid-episode lifting command resamples now refresh kinematics and the
+  multi-cube reward cache, so observations and rewards no longer see
+  pre-teleport object positions for one step after each resample.
+- ``UniformVelocityCommand``'s ``init_velocity_prob`` path no longer writes
+  the previous episode's terminal pose back into the sim on reset. It read
+  derived kinematics before ``forward()`` ran and rewrote the root pose; it
+  now reads only qpos for the orientation and writes only the root velocity.
+- ``init_velocity_prob`` now applies on episode reset only. A mid-episode
+  timer resample used to also teleport the root velocity, which ran after
+  ``step()``'s forward and left velocity observations stale for one step.
+- ``Entity.set_joint_position_target`` and its velocity/effort/tendon/site
+  siblings now select the outer product when both ``env_ids`` and the element
+  ids are tensors, instead of pairing them elementwise.
+- ``MotionCommand`` now refreshes kinematics after a timer-expiry resample
+  (finite ``resampling_time_range``), matching its wraparound path.
+- ``CircularBuffer`` lag retrieval now clamps to the oldest retained frame;
+  a lag beyond the buffer length used to wrap around to a newer frame.
+- Camera sensor caches are now invalidated after ``sense()``, so a
+  pre-sense read with ``clone_data=True`` can no longer pin the previous
+  step's frame into the observations (mirrors the raycast fix for
+  :issue:`998`).
+- ``reset(env_ids=...)`` no longer appends a frame to every env's observation
+  history and delay buffers; only the reset envs receive their post-reset
+  frame. Previously, each manual partial reset gave the other envs a duplicate
+  frame, shortening their effective history and drifting their delay
+  schedules.
+- ``reset(env_ids=...)`` no longer advances stateful commands in
+  environments that were not reset. Previously a partial reset gave every
+  environment an extra command update, so with ``auto_reset=False`` a
+  ``MotionCommand`` reference motion played at twice the normal speed and
+  could teleport non-reset robots via the wraparound resample. The adaptive
+  sampling EMA also no longer folds on resets, matching auto-reset
+  training dynamics. :issue:`1138`
+- Interval event timers are now resampled on episode reset for function-based
+  terms, as documented. Previously the countdown carried across episodes, so a
+  new episode's first ``push_robot`` in the velocity and tracking tasks could
+  fire arbitrarily soon after spawn; with mixed function and class interval
+  terms, reset also wrote into the wrong timer slots. Note this changes push
+  timing relative to earlier training runs, and an interval term whose range
+  exceeds the episode length is now re-armed on every reset and will never
+  fire.
+- ``RayCastSensorCfg.include_geom_groups`` now raises on values outside
+  ``[0, mjNGROUP)`` instead of silently excluding every geom.
+- Geoms with a negative group no longer pick up group 5's visibility toggle in
+  the Viser viewer.
+
+Version 1.5.3 (July 22, 2026)
+-----------------------------
+
+Changed
+^^^^^^^
+
+- The Viser reward bar panel's term cap is now configurable via
+  ``ViewerConfig.reward_bar_max_terms``, so environments with more than 20
+  reward terms can show them all. Defaults to 20, preserving previous behavior.
+  :issue:`1079`
+
+Fixed
+^^^^^
+
+- Bumped ``pillow`` (12.3.0), ``onnx`` (1.22.0), and ``soupsieve`` (2.9.1) in the
+  lockfile to pick up security fixes.
+- Fixed raycast sensor debug visualization and observations lagging one step
+  behind the sensed hits. ``sense()`` rebinds the hit tensors after the cache had
+  already been repopulated by a pre-sense reward read, so ``.data`` returned the
+  previous step's hits; the cache is now invalidated after ``postprocess_rays``.
+  With ``ray_alignment="yaw"`` this made debug rays appear tilted by the foot's
+  per-step motion instead of vertical. :issue:`998`
+- Restored ONNX uploads and W&B run metadata for velocity and manipulation
+  training when using RSL-RL's current ``WandbLogWriter`` logger name.
+- The Viser reward bar panel no longer *silently* drops reward terms beyond
+  ``max_terms``; it now emits a warning listing the hidden terms. Previously
+  environments with more than 20 reward terms had the overflow disappear from
+  the bar panel with no indication. :issue:`1079`
+- Fixed the ``terrain_levels_vel`` curriculum promoting every env from level 0
+  to level 1 on the initial reset, ignoring ``max_init_terrain_level=0``. Before
+  the first step the robot sits at its spawn pose rather than a walked-to
+  position, so the distance check was spurious; terrain levels are now frozen on
+  that first reset. :issue:`1094`
+- Fixed the velocity task's actor ``joint_pos`` observation not being biased by
+  the ``encoder_bias`` domain randomization, so the encoder bias only affected
+  actions and never the observed joint positions. The actor now observes biased
+  joint positions while the critic keeps the true (unbiased) values as
+  privileged information, matching the tracking task.
+  See `discussion #1065 <https://github.com/mujocolab/mjlab/discussions/1065>`_.
+- Hardened ``fit_terrain_normal`` against non-finite raycast hits. A single env
+  with a diverged state produced a NaN/Inf covariance that made
+  ``torch.linalg.eigh`` raise and abort the whole batch; such rows now fall back
+  to the up vector. This stops the hard crash so a diverged env can be reset
+  normally; it does not by itself make a diverged env's downstream reward finite.
+  :issue:`912`
+- Enabled ``obs_normalization`` on the Go1 velocity actor and critic to match
+  the other velocity tasks. Without it, extreme-but-finite observations on rough
+  terrain drove value/policy divergence that eventually surfaced as a
+  ``normal expects all elements of std >= 0.0`` crash. Note that Go1 velocity
+  checkpoints trained before this change carry no normalizer buffers and will no
+  longer load; retrain from scratch. :issue:`870` :issue:`1044` :issue:`1053`
+- Fixed ``ContactSensor`` air-time tracking accumulating float32 sim-clock
+  differences, whose quantization error grows with the clock magnitude and made
+  ``compute_first_contact`` / ``compute_first_air`` miss touchdowns on long runs.
+  The exact float64 substep ``dt`` is now accumulated instead. :issue:`1101`
+- Bumped ``mujoco-warp`` to 3.10.0.3, fixing a CUDA 700 illegal memory access in
+  ``smooth.crb`` triggered by startup mass domain randomization (via
+  ``set_const``) once ``num_envs >= 128`` on consumer Ada GPUs. :issue:`1108`
+
+Version 1.5.2 (July 17, 2026)
+-----------------------------
+
+Fixed
+^^^^^
+
+- Fixed CUDA illegal memory accesses when domain randomization triggers
+  ``set_const`` with multiple environments. ``actuator_acc0`` is now expanded
+  per environment before MuJoCo Warp recomputes it.
+- Fixed ``MaterialCfg.reflectance`` being ignored when building the MuJoCo
+  spec. Contribution by @bd-pmorais.
+
+Version 1.5.1 (July 15, 2026)
+-----------------------------
+
+Added
+^^^^^
+
+- Added ``MeshCfg``, a spec editor that matches mesh assets by name and edits
+  their asset-level attributes. The first attribute is ``maxhullvert``, which
+  caps the collision convex hull's vertex count to lower narrowphase cost.
+- Added ``SimulationCfg.broadphase`` and ``SimulationCfg.broadphase_filter``
+  to configure MuJoCo Warp's broadphase collision algorithm and
+  bounding-volume filters.
+
+Changed
+^^^^^^^
+
+- Enabled skybox rendering for camera sensors. Contribution by @bd-pmorais.
+- Bumped the minimum ``mujoco-warp`` to 3.10.0.2, which fixes ``qfrc_constraint``
+  being populated incorrectly across vectorized environments (:issue:`1086`).
+  Earlier 3.10.0.x releases are no longer supported.
+- Command delay on fusable actuators (ideal PD, DC motor) now applies one shared
+  lag per environment across all fused actuators sharing a delay config, matching
+  the built-in actuator path, rather than an independent lag per actuator group
+  (:issue:`1035`).
+
+Fixed
+^^^^^
+
+- Fixed ``TerrainGenerator`` overwriting custom geom names set by sub-terrain
+  functions with the default ``terrain_{i}`` name. Only unnamed geoms are now
+  auto-named.
+- Fixed ``TorchArray`` not expanding world-shared model fields to ``nworld``
+  with mujoco_warp 3.10.0.2, which allocates them as real size-1 arrays
+  instead of stride-0 broadcast views. Multi-env indexing of fields like
+  ``soft_joint_pos_limits`` raised ``IndexError`` during resets (:issue:`1093`).
+- Fixed ``mdp.bad_orientation`` returning NaN when float32 rounding in
+  ``quat_apply_inverse`` pushed the projected-gravity z-component slightly
+  outside ``[-1, 1]``, making ``torch.acos`` return NaN and silently
+  suppressing the termination for flipped robots. The argument is now clamped
+  to ``[-1, 1]``.
+- Fixed a crash when using command delay on ideal PD (or other custom)
+  actuators whenever ``num_envs`` differed from the number of delayed targets,
+  and fused ideal PD and DC motor actuators sharing a transmission and delay
+  config into a single gather, delay, control-law evaluation, and control
+  write, removing per-group host overhead (:issue:`1035`).
+
+Version 1.5.0 (June 28, 2026)
+-----------------------------
+
+Added
+^^^^^
+
+- Added ``reduce="max"`` to ``MetricsTermCfg`` for reporting episode-peak values
+  (e.g. peak power, peak contact force) without needing stateful wrapper classes.
+- Added ``BuiltinDcMotorActuator``, a native MuJoCo ``<dcmotor>`` wrapper.
+  Supports voltage / position / velocity input modes with back-EMF,
+  configurable motor constants, and optional integral, slew, inductance,
+  thermal, LuGre, and cogging extensions.
+- Added ``scale_with_difficulty`` to ``HfRandomUniformTerrainCfg``. When
+  enabled, the noise amplitude scales with difficulty (flat at 0, full
+  ``noise_range`` at 1) so the terrain progresses in a curriculum. Defaults to
+  ``False``, preserving the previous difficulty-independent behavior.
+- Added material domain randomization functions for MuJoCo Warp RGB rendering:
+  ``dr.mat_emission``, ``dr.mat_specular``, ``dr.mat_shininess``, and
+  ``dr.mat_texrepeat``.
+
+Changed
+^^^^^^^
+
+- Bumped ``rsl-rl-lib`` from 5.2.0 to 5.4.0.
+- Bumped ``mujoco`` and ``mujoco-warp`` to 3.10, both pinned from PyPI. The
+  ``py.mujoco.org`` nightly index and the ``mujoco-warp`` git pin are dropped, so
+  resolution no longer breaks when nightly wheels are garbage-collected.
+
+  .. warning::
+
+     ``SimulationCfg.ls_parallel`` is deprecated and now ignored, since parallel
+     linesearch was removed upstream in MuJoCo Warp. Setting it emits a
+     ``DeprecationWarning``; remove it from any ``SimulationCfg`` you construct.
+- Curriculum-mode terrain difficulty is now deterministic across rows
+  and reaches the configured ``difficulty_range`` endpoints
+  (:issue:`1027`).
+- Heightfield terrains now color by absolute height with a diverging palette
+  (cool below the ground plane, green at ground level, warm above) on a fixed
+  scale, replacing the per-patch normalization. Color is now consistent across
+  terrains, and low-amplitude terrain such as ``random_rough`` reads as gently
+  tinted ground instead of high-contrast noise.
+- ``BoxNestedRingsTerrainCfg`` now builds uniform-height concentric ridges
+  whose separating gaps widen with difficulty, replacing the random per-ring
+  heights. Rings are colored by height (like the other terrains) and the outer
+  border matches the ring height.
+- Terrain generation no longer prints timing information to stdout.
+
+Fixed
+^^^^^
+
+- Fixed domain randomization events that target different ``axes`` of the same
+  model field (e.g. two ``dr.geom_size`` events scaling axis 0 and axis 1
+  separately) silently clobbering each other. Each event now writes back only
+  the axes it targeted, so per-axis events compose (:issue:`1042`).
+- Regenerated the bundled MuJoCo type stubs, which had drifted from the
+  installed mujoco version. CI now regenerates them and fails if they are
+  stale, so they stay in sync going forward. Run ``make stubs`` to update them
+  (:issue:`1048`).
+- Fixed ``select_gpus`` crashing when ``CUDA_VISIBLE_DEVICES`` contains MIG
+  UUIDs instead of numeric indices.
+- Fixed pyramid-stairs terrains (``BoxPyramidStairsTerrainCfg``,
+  ``BoxInvertedPyramidStairsTerrainCfg``, and ``BoxOpenStairsTerrainCfg``)
+  leaving an empty, geometry-free border at difficulty 0, where the step
+  height collapses to zero. The flat border frame is now always generated as
+  solid geometry flush with the ground (:issue:`1033`).
+- Fixed ``HfPerlinNoiseTerrainCfg`` failing to compile at difficulty 0, where
+  the target height collapses to zero and MuJoCo rejects the non-positive
+  heightfield size.
+- Fixed ``BoxRandomGridTerrainCfg`` producing NaN colors (and failing to build)
+  at difficulty 0, where the grid height is zero and the color normalization
+  divided by zero.
+- Fixed the center platform z-fighting with surrounding geometry in
+  ``BoxRandomGridTerrainCfg`` (grid cells were left underneath the platform) and
+  ``BoxRandomSpreadTerrainCfg`` (the platform duplicated the floor surface).
+- Fixed ``BoxNarrowBeamsTerrainCfg`` square platform corners protruding between
+  the beams at high difficulty; the platform now shrinks to stay within the
+  beams' angular coverage.
+- Fixed ``BoxSteppingStonesTerrainCfg`` reconfiguring abruptly at a difficulty
+  threshold, where the stone grid re-tiled as its spacing crossed an integer
+  boundary, and leaving an oversized gap around the center platform. The grid is
+  now difficulty-independent and the platform snaps to it as a clean island.
+- Fixed ``train --video``, ``play``, and ``demo`` crashing with ``OpenGL
+  platform library not loaded`` on headless Linux hosts that don't pre-set
+  ``MUJOCO_GL``. The default is now applied in ``mjlab/__init__.py`` (Linux
+  only) so it takes effect before mujoco's GL backend selection runs.
+- Fixed motion tracking re-anchoring to a stale robot pose after a mid-episode
+  motion resample. ``MotionCommand._update_command`` now calls ``sim.forward()``
+  after resampling so relative body poses read the post-teleport state
+  (:issue:`1068`).
+
+Version 1.4.0 (May 26, 2026)
+----------------------------
+
+Added
+^^^^^
+
+- Added ``BuiltinPdActuator``, the implicit-integration version of
+  ``IdealPdActuator``. Same interface (position + velocity targets,
+  kp/kd gains), but expresses the PD as native MuJoCo ``<position>``
+  and ``<velocity>`` elements so the ``implicit`` / ``implicitfast``
+  integrators include the kp/kd derivatives in their velocity update.
+  The actuator stays stable at gain/timestep combinations where
+  explicit Python PD would diverge, which matters when you want to
+  run a real motor's stiff on-board PD gains in sim. ``effort_limit``
+  is enforced as a sum-clamp on the two PD terms via
+  ``jnt_actfrcrange`` (or ``tendon_actfrcrange``). Supported by
+  ``dr.pd_gains`` and ``dr.effort_limits``.
+- Added ``mdp.projected_gravity_from_sensor``, an observation that derives
+  projected gravity from a ``framezaxis`` up-vector sensor (negated) rather
+  than from the root body orientation. Unlike ``mdp.projected_gravity``, it
+  reflects the sensor's site frame, so it can observe IMU mounting domain
+  randomization (e.g. via ``dr.site_quat``). Go1 and G1 ship an
+  ``imu_upvector`` sensor for this.
+- Added ``DebugVisualizer.add_box`` for drawing an axis-oriented box
+  primitive, mirroring ``add_ellipsoid``. Supported by both the native
+  and Viser viewers. ``size`` is the box half-extents (:issue:`992`).
+- Added ``--log-root`` CLI option to ``train``, ``play``, and ``evaluate``
+  scripts for choosing where training logs are stored. Defaults to
+  ``logs/rsl_rl`` (unchanged behavior). Useful for directing outputs to a
+  scratch disk or shared mount.
+- ``RewardManager``, ``TerminationManager``, and ``MetricsManager`` now
+  validate that every term function returns a tensor of shape
+  ``(num_envs,)`` when evaluated, raising a clear ``ValueError``
+  naming the offending term instead of silently broadcasting or crashing
+  with an opaque error later during training.
+- Added ``ContactSensor.primary_names`` property to expose the resolved
+  primary names in the order they appear along the per-contact axis of the
+  output tensors. This makes it possible to map a contact-data column back
+  to the primary it belongs to (:issue:`914`).
+- Added per-world mesh variant support via ``VariantEntityCfg``. Each
+  world in a batched simulation can now use a different mesh asset for
+  the same logical entity (e.g. world 0 holds a cube, world 1 a
+  sphere). Variants are passed as a ``dict[str, Callable]`` of named
+  spec callables; the optional ``assignment`` field controls how worlds
+  map to variants and accepts ``None`` (uniform), a ``dict[str, float]``
+  of per-variant weights, or a custom ``Callable[[int], Sequence[int]]``.
+  Mesh-derived constants (collision bounds, body inertials, subtree
+  mass, inverse weights) are compiled per-variant and stored as
+  per-world arrays in the Warp model, so domain randomization, the
+  native viewer, the offscreen renderer, and the Viser viewer all pick
+  up the variant assignment automatically. Variants must share the
+  same kinematic structure (same bodies, joints, joint types); only
+  mesh geoms may differ. Assignment is fixed at simulation init. See
+  :ref:`heterogeneous_worlds` for usage. With help from @XiangruiJiang.
+- Per-world mesh variants now support per-variant materials and textures.
+  Each variant can reference its own named material, which is automatically
+  prefixed and scattered via ``geom_matid`` alongside the existing
+  ``geom_dataid`` table. Variants without a material get ``matid = -1``.
+  Contribution by @omarrayyann.
+- Added ``dr.geom_matid`` to randomize which baked material each geom uses
+  per environment, sampling uniformly from ``asset_cfg.material_names``.
+  Contribution by @bd-pmorais.
+
+Changed
+^^^^^^^
+
+- ``Entity`` now raises a clear error at construction when its spec contains
+  more than one freejoint. An entity models a single system rooted at one
+  body, so it has at most one freejoint; a second one was previously accepted
+  silently and only surfaced later as a cryptic shape mismatch when writing
+  root state. Model each detached floating body as its own entry in
+  ``SceneCfg.entities`` instead.
+- Changed ``compute_root_relative_mpkpe`` to re-anchor the reference to the
+  robot's root each step, removing yaw drift as well as translation so it
+  measures intrinsic body pose error.
+- Changed ``compute_joint_velocity_error`` from an L2 norm to a per-joint
+  RMS, so it no longer scales with the number of joints.
+- Bumped ``mujoco`` to 3.8 and ``mujoco-warp`` to 3.8.0. The ``multiccd``
+  enable flag was removed in mujoco 3.8 (it became default-on), so configs
+  that listed ``"multiccd"`` in ``MujocoCfg.enableflags`` need to drop it.
+- Camera segmentation now matches ``mujoco_warp``'s typed segmentation
+  output. ``CameraSensorData.segmentation`` stores ``(object_id,
+  object_type)`` pairs in shape ``[B, H, W, 2]`` instead of the previous
+  legacy geom-id-only layout. Contribution by @tkelestemur.
+- Sped up ``RayCaster`` post-processing by removing boolean-mask indexing
+  operations and replacing them with ``masked_fill_`` plus a clamped-distance
+  formulation of ``hit_pos_w`` that places misses at the world origin. This
+  removes all CUDA syncs from the ray post-process, letting the CPU thread
+  proceed while GPU-based sensing runs. Contribution by @bd-pdomanico.
+- Bumped ``rsl-rl-lib`` from 5.0.1 to 5.2.0. This brings ``torch.compile`` support for
+  PPO and Distillation, and optional std clamping and constant std in
+  ``GaussianDistribution``. No code changes required on the mjlab side.
+- ``TerrainEntityCfg`` debug visualization sites (environment origins,
+  terrain origins, flat patches) are now off by default. Set
+  ``debug_vis=True`` to re-enable them. The sites inflated ``nsite`` and
+  caused a measurable slowdown in the per-step ``site_local_to_global``
+  kernel (:issue:`942`).
+- Task package load failures during ``mjlab`` import now print the full
+  traceback (and the entry point's module path) to ``stderr`` instead of
+  just the exception message, making it easier to pinpoint the source of
+  import errors when running commands like ``list-envs`` (:issue:`910`).
+  Contribution by @saikishor.
+- Clarified ``ContactSensor`` shape conventions: per-contact fields
+  (``found``, ``force``, ``torque``, ``dist``, ``pos``, ``normal``,
+  ``tangent``) have shape ``[B, P * num_slots, ...]`` while per-primary
+  air-time fields (``current_air_time``, ``last_air_time``,
+  ``current_contact_time``, ``last_contact_time``) have shape ``[B, P]``,
+  where ``P`` is the number of resolved primaries (:issue:`914`).
+- Event functions now share a single ``resolve_env_ids`` helper to expand
+  ``env_ids=None`` to all environments, replacing five copies of the same
+  guard. ``push_by_setting_velocity`` and ``apply_external_force_torque``
+  accept ``env_ids=None`` too, so they work as global-time interval terms.
+  Documented when to use ``apply_external_force_torque`` (a constant,
+  self-managed wrench) versus ``apply_body_impulse`` (transient, automatic
+  impulses) versus ``push_by_setting_velocity`` (an instantaneous velocity
+  kick).
+
+Fixed
+^^^^^
+
+- Removed use of deprecated ``warp-lang`` symbols (``wp.context.runtime``
+  and ``wp.context.Device``) that were dropped in newer ``warp-lang``
+  releases, causing ``AttributeError: module 'warp' has no attribute
+  'context'`` at import/runtime. mjlab now uses
+  ``wp.get_cuda_driver_version()`` and ``wp.Device`` instead
+  (:issue:`967`). Contribution by @rdeits.
+- Fixed the tracking ``evaluate`` script scoring each metric against the
+  next motion frame; the reference is now snapshotted before each step to
+  match the reward.
+- Fixed the tracking end-effector metrics silently scoring zero for an
+  unknown body name; they now raise ``ValueError``.
+- Fixed ``compute_mpkpe`` measuring root-relative instead of global error;
+  it now uses the global reference ``body_pos_w`` (:issue:`1006`).
+- Fixed heavy flicker in offscreen training videos on rough-terrain tasks.
+  The renderer recomputed its context "neighbor" robots every frame from
+  ``env_origins``, which the terrain curriculum mutates on reset, so the
+  neighbor set kept changing and robots popped in and out. The neighbor
+  set is now computed once and cached (:issue:`979`).
+- Fixed command delay only applying to an actuator's position target.
+  ``IdealPdActuator`` and ``DcMotorActuator`` also use velocity and effort, which
+  arrived undelayed and out of sync; all command targets now share one delay.
+  Zero-reference setups are unaffected.
+- Fixed duplicate random seeds across nodes in multi-node training. The
+  per-process seed offset in ``scripts/train.py`` now uses the global
+  ``RANK`` instead of ``LOCAL_RANK``. Contribution by @bd-pdomanico.
+- Fixed ``apply_body_impulse`` firing an impulse on the very first step (and
+  the first step after every reset) instead of starting with a cooldown as
+  documented. The cooldown is now sampled lazily on the first call so impulse
+  timing is decorrelated from episode resets (:issue:`973`).
+- Fixed ``dr.pd_gains`` and ``dr.effort_limits`` silently no-oping when
+  passed an ``Operation`` object (e.g. ``dr.scale``) instead of a string.
+  Both functions now accept ``Operation | str`` like every other DR event
+  and raise ``ValueError`` for unsupported operations (:issue:`971`).
+- Fixed ``ContactSensor`` with ``global_frame=True`` and
+  ``reduce`` ∈ {``"none"``, ``"mindist"``, ``"maxforce"``} producing forces
+  rotated onto the wrong axis. The contact-frame→world rotation matrix had
+  its columns ordered ``[tangent, tangent2, normal]`` instead of
+  ``[normal, tangent, tangent2]``, projecting the normal-force component
+  onto a tangent direction. Contribution by @bd-pdomanico.
+- Fixed ``extras["log"]`` entries written by reward terms (e.g. ``Metrics/*``
+  values in velocity tasks) being silently discarded on any step where at
+  least one environment resets. ``_reset_idx`` was clearing the dict after
+  ``reward_manager.compute()`` had already populated it. The clear now
+  happens at the top of ``step()`` and ``reset()`` so that all entries
+  survive (:issue:`957`).
+- Fixed ``ContactSensor.compute_first_contact`` and ``compute_first_air``
+  occasionally missing events when a contact began or ended right at the
+  last physics substep of a control step. ``current_contact_time`` /
+  ``current_air_time`` accumulate in float32 and can drift a few ULPs past
+  ``dt``, but the default ``abs_tol`` of ``1e-8`` sat at the noise floor
+  and rejected the comparison. Raised the default to ``1e-6``, which stays
+  well below typical control ``dt`` while comfortably covering float32
+  accumulation noise (:issue:`933`). Contribution by @paLeziart.
+- Fixed ``out_of_terrain_bounds`` using stale terrain dimensions. It read
+  ``TerrainGeneratorCfg.num_cols`` directly, which is ignored in curriculum
+  mode (the generator uses ``len(sub_terrains)`` columns instead), and it
+  did not account for ``border_width``. The termination now reads the
+  effective grid shape from ``terrain.terrain_origins`` and includes the
+  border in the footprint, so robots no longer reset while still on valid
+  terrain (or fail to reset after running off it) (:issue:`923`).
+- ``ObservationManager`` now skips observation groups that end up with
+  zero active terms (e.g. all terms set to ``None``) with a log message,
+  instead of crashing later in ``torch.stack``/``torch.cat``. This lets
+  a shared runner config define groups that become empty under certain
+  runtime flags (e.g. model-specific terms all disabled for one variant).
+  The whole group can still be set to ``None`` to disable it explicitly.
+- Fixed a runtime broadcast error in ``ContactSensor`` when combining
+  ``num_slots > 1`` with ``track_air_time=True`` and more than one primary.
+  Air-time tracking now reduces ``found`` across slots so that a primary is
+  considered in contact when any of its slots reports a match (:issue:`914`).
+- Updated the ``create_new_task.ipynb`` Colab tutorial to import
+  ``XmlActuatorCfg`` instead of the removed ``XmlVelocityActuatorCfg``.
+  Added a regression test (``tests/test_notebooks.py``) that parses each
+  notebook cell and verifies that every ``from mjlab... import X``
+  reference resolves, so future renames in the mjlab public API can't
+  silently rot the tutorials (:issue:`913`).
+- Fixed ``ObservationManager`` silently sharing a single ``NoiseModelCfg``
+  instance across observation groups that declared terms with the same
+  name. ``_group_obs_class_instances`` was keyed by term name alone, so
+  the last group processed in ``_prepare_terms`` overwrote earlier
+  groups' instances. Symptoms included the wrong noise config being
+  applied, shared per-episode state for ``NoiseModelWithAdditiveBias``
+  (e.g. bias drawn from the wrong ``bias_noise_cfg``), and missed
+  ``reset()`` calls for overwritten instances. Instances are now keyed
+  by ``(group_name, term_name)`` so each group owns its own noise model.
+- Fixed ``CurriculumManager.get_active_iterable_terms`` raising
+  ``TypeError`` when a term's state was a dict. The dict branch indexed
+  the output list by term name instead of appending to the local ``data``
+  list. No in-tree caller currently invokes this method, so the bug was
+  latent.
+
+Version 1.3.0 (April 14, 2026)
+------------------------------
+
+Added
+^^^^^
+
+- Added ``ManagerBasedRlEnvCfg.auto_reset`` flag. When ``True`` (default),
+  ``step()`` continues to reset done environments in place and returns the
+  post-reset observation. When ``False``, ``step()`` skips the reset block
+  and returns the terminal observation directly; the caller must call
+  ``reset(env_ids=...)`` for done environments before the next ``step()``
+  or a ``RuntimeError`` is raised. Enables access to the true terminal
+  state for algorithms that need it. Note that mjlab's bundled ``train.py``
+  uses rsl_rl's ``OnPolicyRunner``, which does not drive manual resets, so
+  ``auto_reset=False`` is intended for custom training loops (:issue:`900`).
+- Added ``ActuatorCfg.viscous_damping`` for passive velocity proportional
+  damping (``f = -b·v``), distinct from the PD derivative gain ``damping``
+  used by position and velocity actuators. Maps to ``<joint damping>`` for
+  JOINT transmission and ``<tendon damping>`` for TENDON transmission.
+  Defaults to ``None`` (preserves the XML value).
+- Added :class:`~mjlab.managers.RecorderManager` for logging observations,
+  actions, or arbitrary environment data during rollouts. Implement a
+  :class:`~mjlab.managers.RecorderTerm` subclass and register it in the
+  ``recorders`` dict on ``ManagerBasedRlEnvCfg``. The manager provides
+  ``record_pre_reset``, ``record_post_reset``, and ``record_post_step``
+  lifecycle hooks with no opinion on how data is stored.
+- Added :func:`~mjlab.envs.mdp.curriculums.termination_curriculum` for
+  scheduling changes to termination term parameters during training,
+  matching the existing ``reward_curriculum`` pattern. Both now share a
+  single internal engine with init-time validation of stage ordering,
+  field existence, and param keys.
+- Added ``reduce`` field to ``MetricsTermCfg``. Setting ``reduce="last"``
+  reports the value from the final step of the episode rather than the
+  episode mean, which is useful for binary success metrics.
+- Added :class:`~mjlab.envs.mdp.actions.RelativeJointPositionAction` for
+  joint position control relative to the current configuration. The target is
+  ``current_pos + action * scale``, so a zero action holds the current
+  configuration rather than commanding the default pose.
+- Added :func:`~mjlab.envs.mdp.dr.pair_friction` for randomizing geom-pair
+  friction overrides (``pair_friction`` in ``mjModel``), with an
+  ``isotropic=True`` option that mirrors the symmetric tangent and roll
+  axes so single-axis randomization does not leave the paired axis stale.
+- Added ``STAIRS_TERRAINS_CFG`` terrain preset for progressive stair
+  curriculum training and ``@terrain_preset`` decorator for composing
+  terrain configurations from reusable presets.
+- Added cartpole balance and swingup tasks (``Mjlab-Cartpole-Balance`` and
+  ``Mjlab-Cartpole-Swingup``) with a :ref:`tutorial <tutorial-cartpole>`
+  that walks through building an environment from scratch.
+- Added :ref:`motion imitation <motion-imitation>` documentation with
+  preprocessing instructions. The README now links here instead of the
+  BeyondMimic repository, which produced incompatible NPZ files when used
+  with mjlab (:issue:`777`).
+- Added ``margin``, ``gap``, and ``solmix`` fields to ``CollisionCfg``
+  for per geom contact parameter configuration (:issue:`766`).
+- NaN guard now captures mocap body poses (``mocap_pos``, ``mocap_quat``)
+  when the model has mocap bodies, enabling full state reconstruction in
+  the dump viewer for fixed-base entities.
+- Implemented ``ActionTermCfg.clip`` for clamping processed actions after
+  scale and offset (:issue:`771`).
+- Added ``qfrc_actuator`` and ``qfrc_external`` generalized force accessors
+  to ``EntityData``. ``qfrc_actuator`` gives actuator forces in joint space
+  (projected through the transmission). ``qfrc_external`` recovers the
+  generalized force from body external wrenches (``xfrc_applied``)
+  (:issue:`776`).
+- Added ``RewardBarPanel`` to the Viser viewer, showing horizontal bars for
+  each reward term with a running mean over ~1 second (:issue:`800`).
+- Added ``per_substep`` flag to ``MetricsTermCfg`` for evaluating metrics
+  once per physics substep inside the decimation loop. The per substep
+  values are averaged within each environment step, so episode averages
+  remain comparable to regular per step metrics.
+- Added ``project-instinct/InstinctMJ`` to the research page's list of
+  projects built on mjlab.
+- Added a Checkpoints tab to the Viser play viewer for hot-swapping
+  checkpoints without restarting. Works with local directories and W&B
+  runs (:issue:`751`). Contribution by @omarrayyann.
+- Added ``"segmentation"`` camera data type for per-pixel geom ID output
+  alongside RGB and depth, and a multi-cube goal-conditioned lifting task
+  (``Mjlab-Multi-Cube-Seg-Yam``) that uses it (:issue:`862`).
+  Contribution by @pthangeda.
+
+Changed
+^^^^^^^
+
+- Renamed the ``list_envs`` console script to ``list-envs`` for consistency
+  with the other hyphenated entry points (``viz-nan``, ``export-scene``).
+  Invoke via ``uv run list-envs``.
+- ``ActuatorCfg.armature`` and ``ActuatorCfg.frictionloss`` now default to
+  ``None`` instead of ``0.0``. ``None`` preserves the value defined in the
+  XML. Previously, builtin actuators would silently overwrite XML joint and
+  tendon properties with zero when these fields were not explicitly set.
+  To restore the old behavior, pass ``armature=0.0`` or ``frictionloss=0.0``
+  explicitly.
+- Actuator delay is now configured inline on any ``ActuatorCfg`` subclass
+  (e.g. ``BuiltinPositionActuatorCfg(..., delay_min_lag=2, delay_max_lag=5)``)
+  instead of wrapping with ``DelayedActuatorCfg``. ``DelayedActuator``,
+  ``DelayedActuatorCfg``, and ``DelayedBuiltinActuatorGroup`` are removed.
+- Removed ``delay_target`` from ``ActuatorCfg``. Delay now always applies to
+  the actuator's ``command_field`` automatically. Multi-target delay
+  (``delay_target=("position", "velocity")``) is no longer supported.
+- ``XmlPositionActuatorCfg``, ``XmlVelocityActuatorCfg``, ``XmlMotorActuatorCfg``,
+  and ``XmlMuscleActuatorCfg`` are replaced by a single ``XmlActuatorCfg`` that auto
+  detects the actuator type from XML. Pass ``command_field=...`` to override detection.
+- Replaced the viser viewer internals with the ``mjviser`` package. Scene
+  creation, mesh conversion, and overlay rendering (contacts, forces,
+  inertia, tendons, joints, frames) are now provided by mjviser. The viewer
+  exposes a new Visualization tab for overlay controls and a Groups tab for
+  geom/site visibility. Debug visualization and warp tensor conversion remain
+  in mjlab's ``MjlabViserScene`` subclass (:issue:`839`).
+- In curriculum terrain mode, each terrain type now gets exactly one column
+  (``num_cols`` is set to ``len(sub_terrains)``). The ``proportion`` field
+  now controls robot spawning distribution across columns rather than column
+  count. Random mode is unchanged (:issue:`811`).
+- ``BoxSteppingStonesTerrainCfg`` stone size now decreases with difficulty,
+  interpolating from the large end of ``stone_size_range`` at difficulty 0
+  to the small end at difficulty 1 (:issue:`785`).
+- Removed deprecated ``TerrainImporter`` and ``TerrainImporterCfg`` aliases.
+  Use ``TerrainEntity`` and ``TerrainEntityCfg`` instead (:issue:`667`).
+- ``Entity.clear_state()`` is deprecated. Use ``Entity.reset()`` instead.
+  ``clear_state`` only zeroed actuator targets without resetting actuator
+  internal state (e.g. delay buffers), which could cause stale commands
+  after teleporting the robot to a new pose.
+- Removed ``EntityData.generalized_force``. The property was bugged (indexed
+  free joint DOFs instead of articulated DOFs) and the name was ambiguous.
+  Use ``qfrc_actuator`` or ``qfrc_external`` instead (:issue:`776`).
+- ``get_wandb_checkpoint_path`` now filters checkpoints server-side via the
+  ``pattern`` parameter, avoiding unnecessary pagination and tolerance to
+  corrupted metadata (:issue:`898`).
+
+Fixed
+^^^^^
+
+- ``train`` and ``play`` now print a top-level usage message when invoked
+  with ``-h`` / ``--help`` and no task argument, pointing users at
+  ``list-envs`` and ``<TASK> --help`` (:issue:`905`).
+- Fixed ghost geom filtering in the Viser viewer. Ghost geoms were selected
+  by collision flags, so collision-disabled robot geoms appeared as ghosts.
+  The viewer now uses visual alpha to determine which geoms to render.
+- Scene now warns when an attached entity or terrain spec has non-default
+  ``<option>`` fields (e.g. ``<flag contact="disable"/>``), which are
+  silently dropped by ``MjSpec.attach()``. Use ``MujocoCfg`` to set
+  simulation options instead (:issue:`885`).
+- Fixed ``SceneEntityCfg`` names and IDs ordering mismatch when
+  ``preserve_order=False`` (:issue:`876`). Contribution by @jsw7460.
+- Fixed ONNX export path resolution in the velocity, manipulation, and
+  tracking runners when a parent directory name contains the word
+  ``"model"`` (:issue:`867`). Contribution by @gokulp01.
+- ``export-scene`` now writes only referenced assets and places them
+  correctly under the output directory. Previously, asset keys containing
+  path traversal could write files outside the output directory, and all
+  spec assets were included regardless of whether the scene XML referenced
+  them (:issue:`858`).
+- ``electrical_power_cost`` now uses ``qfrc_actuator`` (joint space) instead
+  of ``actuator_force`` (actuation space) for mechanical power computation.
+  Previously the reward was incorrect for actuators with gear ratios other
+  than 1 (:issue:`776`).
+- ``create_velocity_actuator`` no longer sets ``ctrllimited=True`` with
+  ``inheritrange=1.0``. This caused a ``ValueError`` for continuous joints
+  (e.g. wheels) that have no position range defined (:issue:`787`).
+- ``write_root_com_velocity_to_sim`` no longer fails with tensor ``env_ids``
+  on floating base entities (:issue:`793`).
+- Joint limits for unlimited joints are now set to [-inf, inf] instead of
+  [0, 0]. Previously the zero range caused incorrect clamping for entities
+  with unlimited hinge or slide joints.
+- Contact force visualization now copies ``ctrl`` into the CPU ``MjData``
+  before calling ``mj_forward``. Actuators that compute torques in Python
+  (``DcMotorActuator``, ``IdealPdActuator``) previously showed incorrect
+  contact forces because the viewer ran with ``ctrl=0``
+  (:issue:`786`).
+- ``BoxSteppingStonesTerrainCfg`` no longer creates a large gap around the
+  platform. Stones are now only skipped when their center falls inside the
+  platform; edges that extend under the platform are allowed since the
+  platform covers them (:issue:`785`).
+- ``dr.pseudo_inertia`` no longer loads cuSOLVER, eliminating ~4 GB of
+  persistent GPU memory overhead. Cholesky and eigendecomposition are now
+  computed analytically for the small matrices involved (4x4 and 3x3)
+  (:issue:`753`).
+- Set terrain geom mass to zero so that the static terrain body does not
+  inflate ``stat.meanmass``, which made force arrow visualization invisible
+  on rough terrain (:issue:`734`, :issue:`537`).
+- Native viewer now syncs ``qpos0`` when domain randomized, fixing incorrect
+  body positions after ``dr.joint_default_pos`` randomization
+  (:issue:`760`).
+- ``command_manager.compute()`` is now called during ``reset()`` so that
+  derived command state (e.g. relative body positions in tracking
+  environments) is populated before the first observation is returned
+  (:issue:`761`).
+- ``RayCastSensor`` with ``ray_alignment="yaw"`` or ``"world"`` now correctly
+  aligns the frame offset when attached to a site or geom with a local offset
+  from its parent body. Previously only ray directions and pattern offsets were
+  aligned, causing the frame position to swing with body pitch/roll
+  (:issue:`775`).
+
+Version 1.2.0 (March 6, 2026)
+-----------------------------
+
+.. admonition:: Breaking API changes
+   :class: attention
+
+   - ``randomize_field`` no longer exists. Replace calls with typed functions
+     from the new ``dr`` module (e.g. ``dr.geom_friction``, ``dr.body_mass``).
+   - ``EventTermCfg`` no longer accepts ``domain_randomization``. The
+     ``@requires_model_fields`` decorator on each ``dr`` function takes care
+     of field expansion automatically.
+   - ``Scene.to_zip()`` is deprecated. Use ``Scene.write(path, zip=True)``.
+   - ``RslRlModelCfg`` no longer accepts ``stochastic``, ``init_noise_std``,
+     or ``noise_std_type``. Use ``distribution_cfg`` instead
+     (e.g. ``{"class_name": "GaussianDistribution", "init_std": 1.0,
+     "std_type": "scalar"}``). Existing checkpoints are automatically
+     migrated on load.
+
+Added
+^^^^^
+
+- Added ``"step"`` event mode that fires every environment step.
+- Added ``apply_body_impulse`` event for applying transient external wrenches
+  to bodies with configurable duration and optional application point offset.
+- ONNX auto-export and metadata attachment for manipulation tasks (lift cube)
+  on every checkpoint save, matching the velocity and tracking task behavior.
+- Multi-frame ``RayCastSensor``: pass a tuple of ``ObjRef`` to ``frame`` for
+  per-site raycasting with independent body exclusion. New properties:
+  ``num_frames``, ``num_rays_per_frame``. New ``RayCastData`` fields:
+  ``frame_pos_w`` and ``frame_quat_w``.
+- ``RingPatternCfg`` ray pattern for concentric ring sampling around each
+  frame.
+- ``TerrainHeightSensor``, a ``RayCastSensor`` subclass that computes
+  per-frame vertical clearance above terrain (``sensor.data.heights``).
+  Velocity task configs now use it for ``feet_clearance``,
+  ``feet_swing_height``, and ``foot_height``, replacing the previous
+  world-Z proxy that was incorrect on rough terrain.
+- Cloud training support via `SkyPilot <https://skypilot.readthedocs.io/>`_
+  and Lambda Cloud, with documentation covering setup, monitoring, and
+  cost management.
+- W&B hyperparameter sweep scripts that distribute one agent per GPU
+  across a multi-GPU instance.
+- Contributing guide with documentation for shared Claude Code commands
+  (``/update-mjwarp``, ``/commit-push-pr``).
+- Added optional ``ViewerConfig.fovy`` and apply it in native viewer camera
+  setup when provided.
+- Native viewer now tracks the first non-fixed body by default (matching
+  the Viser viewer behavior introduced in
+  ``716aaaa58ad7bfaf34d2f771549d461204d1b4ba``).
+- New ``dr`` module (``mjlab.envs.mdp.dr``) replacing ``randomize_field``
+  with typed per-field domain randomization functions. Each function
+  automatically recomputes derived fields via ``set_const``. Highlights:
+
+  - Camera and light randomization: ``dr.cam_fovy``, ``dr.cam_pos``,
+    ``dr.cam_quat``, ``dr.cam_intrinsic``, ``dr.light_pos``,
+    ``dr.light_dir``. Camera and light names are now supported in
+    ``SceneEntityCfg`` (``camera_names`` / ``light_names``).
+  - ``dr.pseudo_inertia`` for physics-consistent randomization of
+    ``body_mass``, ``body_ipos``, ``body_inertia``, and ``body_iquat``
+    via the pseudo-inertia matrix parameterization (Rucker & Wensing
+    2022). Replaces the removed ``dr.body_inertia`` /
+    ``dr.body_iquat``.
+  - ``dr.geom_size`` with automatic recomputation of ``geom_rbound``
+    and ``geom_aabb`` for broadphase consistency.
+  - ``dr.tendon_armature`` and ``dr.tendon_frictionloss``.
+  - ``dr.body_quat``, ``dr.geom_quat``, and ``dr.site_quat`` with RPY
+    perturbation composed onto the default quaternion.
+  - Extensible ``Operation`` and ``Distribution`` types. Users can define
+    custom operations and distributions as class instances and pass them
+    anywhere a string is accepted. Built-in instances (``dr.abs``,
+    ``dr.scale``, ``dr.add``, ``dr.uniform``, ``dr.log_uniform``,
+    ``dr.gaussian``) are exported from the ``dr`` module.
+  - ``dr.mat_rgba`` for per-world material color randomization. Tints
+    the texture color, useful for randomizing appearance of textured
+    surfaces. Material names are now supported in ``SceneEntityCfg``
+    (``material_names``).
+  - Fixed ``dr.effort_limits`` drifting on repeated randomization.
+  - Fixed ``dr.body_com_offset`` not triggering ``set_const``.
+
+- ``export-scene`` CLI script to export any task scene or asset_zoo entity
+  (``g1``, ``go1``, ``yam``) to a directory or zip archive for inspection
+  and debugging.
+
+- ``yam_lift_cube_vision_env_cfg`` now randomizes cube color (``dr.geom_rgba``)
+  on every reset when ``cam_type="rgb"``.
+
+- The native viewer now reflects per-world DR changes to visual model fields
+  on each reset. Geom appearance, body and site poses, camera parameters,
+  and light positions are all synced from the GPU model before rendering.
+  Inertia boxes (press ``I``) and camera frustums (press ``Q``) update
+  correctly when the corresponding fields are randomized. See
+  :doc:`randomization` for viewer-specific caveats.
+
+- ``MaterialCfg.geom_names_expr`` for assigning materials to geoms by
+  name pattern during ``edit_spec``.
+
+- ``TerrainEntityCfg`` now exposes ``textures``, ``materials``, and
+  ``lights`` as configurable fields (previously hardcoded). Set
+  ``textures=()``, ``materials=()`` to use flat ``dr.geom_rgba``
+  instead of the default checker texture.
+
+- ``DebugVisualizer`` now supports ellipsoid visualization via
+  ``add_ellipsoid``.
+
+- Interactive velocity joystick sliders in the Viser viewer. Enable the
+  joystick under Commands/Twist to override velocity commands with manual
+  sliders for ``lin_vel_x``, ``lin_vel_y``, and ``ang_vel_z``
+  (`#666 <https://github.com/mujocolab/mjlab/issues/666>`_).
+- Per-term debug visualization toggles in the Viser viewer. Individual
+  command term visualizers (e.g. velocity arrows) can now be toggled
+  independently under Scene/Debug Viz.
+- Viewer single-step mode: press RIGHT arrow (native) or click "Step"
+  (Viser) to advance exactly one physics step while paused.
+- Viewer error recovery: exceptions during stepping now pause the viewer
+  and log the traceback instead of crashing the process.
+- Native viewer runs forward kinematics while paused, keeping
+  perturbation visuals accurate.
+- Viewer speed multipliers use clean power-of-2 fractions (1/32x to 1x).
+
+- Visualizers display the realtime factor alongside FPS.
+
+- ``joint_torques_l2`` now respects ``SceneEntityCfg.actuator_ids``,
+  allowing penalization of a subset of actuators instead of all of them
+  (`#703 <https://github.com/mujocolab/mjlab/pull/703>`_). Contribution by
+  `@saikishor <https://github.com/saikishor>`_.
+
+- Terrain is now a proper ``Entity`` subclass (``TerrainEntity``). This
+  allows domain randomization functions to target terrain parameters
+  (friction, cameras, lights) via ``SceneEntityCfg("terrain", ...)``.
+  ``TerrainImporter`` / ``TerrainImporterCfg`` remain as aliases but will be
+  deprecated in a future version.
+- Added ``upload_model`` option to ``RslRlBaseRunnerCfg`` to control W&B model
+  file uploads (``.pt`` and ``.onnx``) while keeping metric logging enabled
+  (`#654 <https://github.com/mujocolab/mjlab/pull/654>`_).
+- ``Scene.write(output_dir, zip=False)`` exports the scene XML and mesh
+  assets to a directory (or zip archive). Replaces ``Scene.to_zip()``.
+- ``Entity.write_xml()`` and ``Scene.write()`` now apply XML fixups
+  (empty defaults, duplicate nested defaults) and strip buffer textures
+  that ``MjSpec.to_xml()`` cannot serialize.
+- ``fix_spec_xml`` and ``strip_buffer_textures`` utilities in
+  ``mjlab.utils.xml``.
+
+Changed
+^^^^^^^
+
+- Native viewer now syncs ``xfrc_applied`` to the render buffer and draws
+  arrows for any nonzero applied forces. Mouse perturbation forces are
+  converted to ``qfrc_applied`` (generalized joint space) so they coexist
+  with programmatic forces on ``xfrc_applied`` without conflict.
+- ``ViewerConfig.OriginType.WORLD`` now configures a free camera at the
+  specified lookat point instead of auto tracking a body. A new ``AUTO``
+  origin type (now the default) preserves the previous auto tracking
+  behavior.
+- Upgraded ``rsl-rl-lib`` from 4.0.1 to 5.0.1. ``RslRlModelCfg`` now
+  uses ``distribution_cfg`` dict instead of ``stochastic`` /
+  ``init_noise_std`` / ``noise_std_type``. Existing checkpoints are
+  automatically migrated on load.
+- Reorganized the Viser Controls tab into a cleaner folder hierarchy:
+  Info, Simulation, Commands, Scene (with Environment, Camera, Debug Viz,
+  Contacts sub-folders), and Camera Feeds. The Environment folder is
+  hidden for single-env tasks and the Commands folder is hidden when no
+  command terms are active.
+- Viser camera tracking is now enabled by default so the agent stays in
+  frame on launch.
+- Self collision and illegal contact sensors now use ``history_length`` to
+  catch contacts across decimation substeps. Reward and termination functions
+  read ``force_history`` with a configurable ``force_threshold``.
+- Replaced the single ``scale`` parameter in ``DifferentialIKActionCfg`` with
+  separate ``delta_pos_scale`` and ``delta_ori_scale`` for independent scaling
+  of position and orientation components.
+- Improved offscreen multi environment framing by selecting neighboring
+  environments around the focused env instead of first N envs.
+- Tuned tracking task viewer defaults for tighter camera framing.
+- Disabled shadow casting on the G1 tracking light to avoid duplicate
+  stacked shadows when robots are close.
+
+Fixed
+^^^^^
+
+- Fixed actuator target resolution for entities whose ``spec_fn`` uses
+  internal ``MjSpec.attach(prefix=...)``
+  (`#709 <https://github.com/mujocolab/mjlab/issues/709>`_).
+- Fixed viewer physics loop starving the renderer by replacing the single
+  sim-time budget with a two-clock design (tracked vs actual sim time).
+  Physics now self-corrects after overshooting, keeping FPS smooth at all
+  speed multipliers.
+- Bundled ``ffmpeg`` for ``mediapy`` via ``imageio-ffmpeg``, removing the
+  requirement for a system ``ffmpeg`` install. Thanks to
+  `@rdeits-bd <https://github.com/rdeits-bd>`_ for the suggestion.
+- Fixed ``height_scan`` returning ~0 for missed rays; now defaults to
+  ``max_distance``. Replaced ``clip=(-1, 1)`` with ``scale`` normalization
+  in the velocity task config. Thanks to `@eufrizz <https://github.com/eufrizz>`_
+  for reporting and the initial fix (`#642 <https://github.com/mujocolab/mjlab/pull/642>`_).
+- Fixed ghost mesh visualization for fixed-base entities by extending
+  ``DebugVisualizer.add_ghost_mesh`` to optionally accept ``mocap_pos`` and
+  ``mocap_quat`` (`#645 <https://github.com/mujocolab/mjlab/pull/645>`_).
+- Fixed viser viewer crashing on scenes with no mocap bodies by adding
+  an ``nmocap`` guard, matching the native viewer behavior.
+- Fixed offscreen rendering artifacts in large vectorized scenes by applying
+  a render local extent override in ``OffscreenRenderer`` and restoring the
+  original extent on close.
+- Fixed ``RslRlVecEnvWrapper.unwrapped`` to return the base environment,
+  ensuring checkpoint state restore and logging work correctly when wrappers
+  such as ``VideoRecorder`` are enabled.
+
+Version 1.1.1 (February 14, 2026)
+---------------------------------
+
+Added
+^^^^^
+
+- Added reward term visualization to the native viewer (toggle with ``P``) (`#629 <https://github.com/mujocolab/mjlab/pull/629>`_).
+- Added ``DifferentialIKAction`` for task-space control via damped
+  least-squares IK. Supports weighted position/orientation tracking,
+  soft joint-limit avoidance, and null-space posture regularization.
+  Includes an interactive viser demo (``scripts/demos/differential_ik.py``) (`#632 <https://github.com/mujocolab/mjlab/pull/632>`_).
+
+Fixed
+^^^^^
+
+- Fixed ``play.py`` defaulting to the base rsl-rl ``OnPolicyRunner`` instead
+  of ``MjlabOnPolicyRunner``, which caused a ``TypeError`` from an unexpected
+  ``cnn_cfg`` keyword argument (`#626 <https://github.com/mujocolab/mjlab/pull/626>`_). Contribution by
+  `@griffinaddison <https://github.com/griffinaddison>`_.
+
+Changed
+^^^^^^^
+
+- Removed ``body_mass``, ``body_inertia``, ``body_pos``, and ``body_quat``
+  from ``FIELD_SPECS`` in domain randomization. These fields have derived
+  quantities that require ``set_const`` to recompute; without that call,
+  randomizing them silently breaks physics (`#631 <https://github.com/mujocolab/mjlab/pull/631>`_).
+- Replaced ``moviepy`` with ``mediapy`` for video recording. ``mediapy``
+  handles cloud storage paths (GCS, S3) natively (`#637 <https://github.com/mujocolab/mjlab/pull/637>`_).
+
+.. figure:: _static/changelog/native_reward.png
+   :width: 80%
+
+Version 1.1.0 (February 12, 2026)
+---------------------------------
+
+Added
+^^^^^
+
+- Added RGB and depth camera sensors and BVH-accelerated raycasting (`#597 <https://github.com/mujocolab/mjlab/pull/597>`_).
+- Added ``MetricsManager`` for logging custom metrics during training (`#596 <https://github.com/mujocolab/mjlab/pull/596>`_).
+- Added terrain visualizer (`#609 <https://github.com/mujocolab/mjlab/pull/609>`_). Contribution by
+  `@mktk1117 <https://github.com/mktk1117>`_.
+
+.. figure:: _static/changelog/terrain_visualizer.jpg
+   :width: 80%
+
+- Added many new terrains including ``HfDiscreteObstaclesTerrainCfg``,
+  ``HfPerlinNoiseTerrainCfg``, ``BoxSteppingStonesTerrainCfg``,
+  ``BoxNarrowBeamsTerrainCfg``, ``BoxRandomStairsTerrainCfg``, and
+  more. Added flat patch sampling for heightfield terrains (`#542 <https://github.com/mujocolab/mjlab/pull/542>`_, `#581 <https://github.com/mujocolab/mjlab/pull/581>`_).
+- Added site group visualization to the Viser viewer (Geoms and Sites
+  tabs unified into a single Groups tab) (`#551 <https://github.com/mujocolab/mjlab/pull/551>`_).
+- Added ``env_ids`` parameter to ``Entity.write_ctrl_to_sim`` (`#567 <https://github.com/mujocolab/mjlab/pull/567>`_).
+
+Changed
+^^^^^^^
+
+- Upgraded ``rsl-rl-lib`` to 4.0.0 and replaced the custom ONNX
+  exporter with rsl-rl's built-in ``as_onnx()`` (`#589 <https://github.com/mujocolab/mjlab/pull/589>`_, `#595 <https://github.com/mujocolab/mjlab/pull/595>`_).
+- ``sim.forward()`` is now called unconditionally after the decimation
+  loop. See :ref:`faq-sim-forward` for details (`#591 <https://github.com/mujocolab/mjlab/pull/591>`_).
+- Unnamed freejoints are now automatically named to prevent
+  ``KeyError`` during entity init (`#545 <https://github.com/mujocolab/mjlab/pull/545>`_).
+
+Fixed
+^^^^^
+
+- Fixed ``randomize_pd_gains`` crash with ``num_envs > 1`` (`#564 <https://github.com/mujocolab/mjlab/pull/564>`_).
+- Fixed ``ctrl_ids`` index error with multiple actuated entities (`#573 <https://github.com/mujocolab/mjlab/pull/573>`_).
+  Reported by `@bwrooney82 <https://github.com/bwrooney82>`_.
+- Fixed Viser viewer rendering textured robots as gray (`#544 <https://github.com/mujocolab/mjlab/pull/544>`_).
+- Fixed Viser plane rendering ignoring MuJoCo size parameter (`#540 <https://github.com/mujocolab/mjlab/pull/540>`_).
+- Fixed ``HfDiscreteObstaclesTerrainCfg`` spawn height (`#552 <https://github.com/mujocolab/mjlab/pull/552>`_).
+- Fixed ``RaycastSensor`` visualization ignoring the all-envs toggle (`#607 <https://github.com/mujocolab/mjlab/pull/607>`_).
+  Contribution by `@oxkitsune <https://github.com/oxkitsune>`_.
+
+Version 1.0.0 (January 28, 2026)
+--------------------------------
+
+Initial release of mjlab.
diff --git a/docs/source/commands.rst b/docs/source/commands.rst
new file mode 100644
index 0000000..90fbc47
--- /dev/null
+++ b/docs/source/commands.rst
@@ -0,0 +1,123 @@
+.. _commands:
+
+Commands
+========
+
+Commands specify what the policy should achieve at each moment: a target
+velocity, a reference trajectory, a goal position. The command manager
+generates these signals, resamples them at configurable intervals, and
+passes them to the policy through the observation system.
+
+
+Registration
+------------
+
+Commands are registered in ``ManagerBasedRlEnvCfg`` as a dictionary
+mapping string names to ``CommandTermCfg`` instances. Unlike the
+function-based terms used by other managers, every command term is a
+class that inherits from ``CommandTerm``.
+
+The ``resampling_time_range`` field controls how often the command
+changes. After each resample the term draws a new timer value uniformly
+from the given ``(min, max)`` range in seconds. Commands are also
+resampled unconditionally on every episode reset.
+
+.. code-block:: python
+
+    commands = {
+        "twist": UniformVelocityCommandCfg(
+            entity_name="robot",
+            resampling_time_range=(3.0, 8.0),
+            ranges=UniformVelocityCommandCfg.Ranges(
+                lin_vel_x=(-1.0, 1.0),
+                lin_vel_y=(-1.0, 1.0),
+                ang_vel_z=(-0.5, 0.5),
+            ),
+        ),
+    }
+
+The ``generated_commands`` observation function reads the current
+command tensor by name and passes it to the policy:
+
+.. code-block:: python
+
+    ObservationTermCfg(
+        func=mdp.generated_commands,
+        params={"command_name": "twist"},
+    )
+
+If the environment has no commands, the manager no-ops all operations
+and returns empty tensors. There is no special handling required.
+
+
+Included command terms
+----------------------
+
+Each task ships with its own command terms tailored to its objective.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 28 72
+
+   * - Term
+     - Description
+   * - ``UniformVelocityCommand``
+     - Generates planar velocity commands ``[v_x, v_y, omega_z]``
+       sampled uniformly from configurable ranges. Supports a standing
+       mode (fraction of environments receive zero velocity) and a
+       heading mode (yaw rate replaced by a proportional controller
+       tracking a sampled heading angle). Used by the velocity task.
+   * - ``LiftingCommand``
+     - Generates a 3D target position for a manipulated object.
+       Supports fixed and dynamic difficulty modes. Tracks metrics
+       including position error and episode success rate. Used by the
+       manipulation task.
+   * - ``MotionCommand``
+     - Streams reference joint positions, velocities, and body poses
+       from a pre-recorded ``.npz`` motion clip. Supports three
+       start-frame sampling modes: ``"start"`` (always frame 0),
+       ``"uniform"`` (random), and ``"adaptive"`` (biased toward
+       difficult regions). At reset the robot is initialized from the
+       sampled frame with optional perturbations. Used by the tracking
+       task.
+
+Each term can render debug visualizations in the interactive viewer
+when ``debug_vis=True`` is set in the configuration. The image below
+shows the ghost visualization from ``MotionCommand``, which renders a
+translucent copy of the robot at the reference pose alongside the
+actual robot.
+
+.. figure:: _static/ghost_visualization.png
+   :align: center
+   :width: 100%
+
+   Viser visualization of the commanded reference motion for the G1 tracking task.
+
+
+Writing custom command terms
+-----------------------------
+
+A custom command term is a class inheriting from ``CommandTerm`` paired
+with a configuration dataclass inheriting from ``CommandTermCfg``. The
+term must implement four methods: ``_resample_command(env_ids)`` to
+sample new goals, ``_update_command(env_ids)`` for per-step updates,
+``_update_metrics()`` for logging, and a ``command`` property returning
+the current goal tensor. The base class manages the resampling timer
+and reset logic automatically.
+
+``_update_command`` is called in two situations. On every environment
+step it receives ``env_ids=None``, meaning update all environments.
+After a reset it is called again with the ids of the environments that
+were just reset, so their command state is brought up to date before
+observations are computed.
+
+The distinction matters when your update advances state, such as
+incrementing a frame index into a reference motion. Apply such advances
+only to ``env_ids`` (all environments when ``None``); otherwise
+resetting a few environments would also advance every other one. Updates
+that simply recompute values from the current simulation state, like a
+heading error, give the same result no matter how often they run and can
+safely ignore ``env_ids``.
+
+The configuration must implement a ``build(env)`` method that
+constructs the paired term instance.
diff --git a/docs/source/contributing.rst b/docs/source/contributing.rst
new file mode 100644
index 0000000..133a2e1
--- /dev/null
+++ b/docs/source/contributing.rst
@@ -0,0 +1,108 @@
+Contributing
+============
+
+Bug fixes and documentation improvements are always welcome.
+
+.. important::
+
+   For new features, please
+   `open an issue <https://github.com/mujocolab/mjlab/issues>`_ first so
+   we can discuss whether it fits the project scope.
+
+
+Development setup
+-----------------
+
+Clone the repository and sync dependencies:
+
+.. code-block:: bash
+
+   git clone https://github.com/mujocolab/mjlab.git && cd mjlab
+   uv sync
+
+Install pre-commit hooks to catch formatting and lint issues before each
+commit:
+
+.. code-block:: bash
+
+   uvx pre-commit install
+
+
+Common commands
+---------------
+
+The ``Makefile`` provides shortcuts for the most common development tasks:
+
+.. code-block:: bash
+
+   make format      # Format code and fix lint errors (ruff)
+   make type        # Type check (ty + pyright)
+   make check       # Format + type check
+   make test-fast   # Run tests, excluding slow ones
+   make test        # Run the full test suite
+   make test-all    # Format + type check + full test suite
+
+You can also run individual tests for faster iteration:
+
+.. code-block:: bash
+
+   uv run pytest tests/test_rewards.py
+
+Type checking (``make type``) is required. PRs that do not pass will be
+blocked.
+
+
+Building the docs
+-----------------
+
+Build the documentation locally:
+
+.. code-block:: bash
+
+   make docs
+
+The HTML output is written to ``docs/_build/``. For live reload during
+editing:
+
+.. code-block:: bash
+
+   make docs-watch
+
+
+Submitting a pull request
+-------------------------
+
+1. Fork the repository and create a feature branch.
+2. Make your changes.
+3. Run ``make test-all`` to verify formatting, type checking, and tests
+   pass.
+4. Add an entry to the "Upcoming version" section in
+   ``docs/source/changelog.rst`` under the appropriate category
+   (Added / Changed / Fixed), following
+   `Keep a Changelog <https://keepachangelog.com/>`_ conventions.
+5. Submit a pull request.
+
+
+Development with Claude Code
+----------------------------
+
+The repository includes a ``CLAUDE.md`` file at the project root. This file
+defines development conventions, style guidelines, and common commands for
+`Claude Code <https://claude.com/claude-code>`_. It is also a useful
+reference for human contributors since it captures the same rules enforced
+in CI.
+
+The project also includes shared commands in ``.claude/commands/``.
+Any contributor with Claude Code installed can invoke them as slash commands.
+
+``/update-mjwarp <commit-hash>``
+   Update the ``mujoco-warp`` dependency to a specific commit. This edits
+   ``pyproject.toml``, runs ``uv lock``, and opens a PR in one step.
+
+   .. code-block:: text
+
+      /update-mjwarp e28c6038cdf8a353b4146974e4cf37e74dda809a
+
+``/commit-push-pr``
+   Stage current changes, commit, push, and open a PR.
+
diff --git a/docs/source/curriculum.rst b/docs/source/curriculum.rst
new file mode 100644
index 0000000..380f895
--- /dev/null
+++ b/docs/source/curriculum.rst
@@ -0,0 +1,184 @@
+.. _curriculum:
+
+Curriculum
+==========
+
+The curriculum manager adjusts training conditions based on policy
+performance. Training begins with an easier problem and difficulty
+increases as the policy demonstrates it can handle the current
+conditions. Common uses include advancing robots to harder terrain,
+widening command velocity ranges, and ramping reward penalty weights
+over the course of training.
+
+Curriculum terms are called at each environment reset. Each term
+receives the environment and the set of resetting environment IDs,
+examines some performance signal, and applies changes to environment
+parameters directly.
+
+.. code-block:: python
+
+    from mjlab.managers.curriculum_manager import CurriculumTermCfg
+
+    curriculum = {
+        "terrain_levels": CurriculumTermCfg(
+            func=mdp.terrain_levels_vel,
+            params={"command_name": "twist"},
+        ),
+    }
+
+The return value of a curriculum function is logged under
+``Curriculum/<term_name>`` in the training metrics.
+
+
+Built-in curriculum functions
+------------------------------
+
+.. list-table::
+   :header-rows: 1
+   :widths: 24 76
+
+   * - Function
+     - Description
+   * - ``terrain_levels_vel``
+     - Measures how far each robot traveled during the episode. Robots
+       that covered enough distance move up one difficulty row in the
+       terrain grid; those that fell short move down. See the terrain
+       curriculum section below.
+   * - ``commands_vel``
+     - Widens velocity command ranges based on training step count.
+       Each stage specifies a step threshold and the new ranges to
+       apply once that threshold is exceeded.
+   * - ``reward_curriculum``
+     - Adjusts a reward term's weight and/or params according to
+       training step thresholds. Replaces the older ``reward_weight``
+       function and also supports modifying reward function parameters.
+   * - ``termination_curriculum``
+     - Adjusts a termination term's params according to training step
+       thresholds. Useful for gradually tightening termination
+       conditions (e.g. energy limits) as training progresses.
+
+
+Reward curriculum
+-----------------
+
+``reward_curriculum`` schedules changes to a reward term's weight or
+keyword arguments as training progresses. Each stage specifies a
+``step`` threshold and an optional ``weight`` or ``params`` update.
+Stages are evaluated in order, and each one whose threshold has been
+reached is applied.
+
+**Ramping a penalty weight**
+
+A common pattern is to introduce a penalty term at low weight early in
+training and increase it once the policy has learned the basics:
+
+.. code-block:: python
+
+    from mjlab.managers.curriculum_manager import CurriculumTermCfg
+
+    curriculum = {
+        "joint_vel_hinge_weight": CurriculumTermCfg(
+            func=mdp.reward_curriculum,
+            params={
+                "reward_name": "joint_vel_hinge",
+                "stages": [
+                    {"step": 0, "weight": -0.01},
+                    {"step": 12000, "weight": -0.1},
+                    {"step": 24000, "weight": -1.0},
+                ],
+            },
+        ),
+    }
+
+**Adjusting reward parameters**
+
+You can also change the parameters passed to the reward function. For
+example, tightening a tracking tolerance as training progresses:
+
+.. code-block:: python
+
+    curriculum = {
+        "track_lin_vel_tighten": CurriculumTermCfg(
+            func=mdp.reward_curriculum,
+            params={
+                "reward_name": "track_linear_velocity",
+                "stages": [
+                    {"step": 0, "params": {"std": 0.5}},
+                    {"step": 20000, "params": {"std": 0.3}},
+                    {"step": 50000, "params": {"std": 0.1}},
+                ],
+            },
+        ),
+    }
+
+**Combining weight and params**
+
+A single stage can update both weight and params at once:
+
+.. code-block:: python
+
+    {"step": 24000, "weight": -1.0, "params": {"max_vel": 1.0}}
+
+
+Termination curriculum
+----------------------
+
+``termination_curriculum`` schedules changes to a termination term's
+parameters as training progresses. This is useful for gradually
+tightening termination conditions once the policy has learned basic
+behaviors.
+
+**Tightening an energy limit**
+
+Start with a permissive energy threshold and reduce it over training:
+
+.. code-block:: python
+
+    from mjlab.managers.curriculum_manager import CurriculumTermCfg
+
+    curriculum = {
+        "energy_threshold": CurriculumTermCfg(
+            func=mdp.termination_curriculum,
+            params={
+                "termination_name": "energy",
+                "stages": [
+                    {"step": 12000, "params": {"threshold": 1000.0}},
+                    {"step": 24000, "params": {"threshold": 700.0}},
+                    {"step": 36000, "params": {"threshold": 400.0}},
+                ],
+            },
+        ),
+    }
+
+The ``time_out`` field on ``TerminationTermCfg`` can also be toggled
+via stages if needed, though this is uncommon in practice.
+
+
+Terrain curriculum
+------------------
+
+The terrain grid used with procedural terrain is a
+``num_rows x num_cols`` matrix of patches. Columns represent terrain
+type variants; rows represent difficulty levels, with row 0 being the
+easiest and row ``num_rows - 1`` the hardest. When
+``TerrainGeneratorCfg.curriculum=True``, each column is assigned exactly
+one terrain type so that difficulty increases monotonically along rows.
+
+At environment construction each environment is assigned a random
+starting row within ``[0, max_init_terrain_level]``. The
+``terrain_levels_vel`` curriculum term promotes or demotes environments
+on each reset based on distance traveled during the episode.
+Environments that reach the maximum level are randomly reassigned to
+any row, maintaining coverage across all difficulty levels. See
+:ref:`terrain` for details on configuring the terrain grid itself.
+
+
+Writing custom curriculum functions
+------------------------------------
+
+A curriculum function accepts ``env`` and ``env_ids``, applies
+parameter changes, and returns a value to log (a scalar tensor, a dict
+of tensors, or ``None``). A typical implementation reads a performance
+metric, decides whether to increase or decrease difficulty, mutates the
+relevant configuration in place, and returns the current difficulty
+level. See :ref:`env-config-term-pattern` for the general pattern.
diff --git a/docs/source/debugging/export_scene.rst b/docs/source/debugging/export_scene.rst
new file mode 100644
index 0000000..a201066
--- /dev/null
+++ b/docs/source/debugging/export_scene.rst
@@ -0,0 +1,50 @@
+.. _export-scene:
+
+Export Scene
+============
+
+The ``export-scene`` script writes a complete scene (XML and mesh assets) to a
+directory for inspection, sharing, or loading in standalone MuJoCo.
+
+Quick start
+-----------
+
+.. code-block:: bash
+
+    # Export a built-in entity by alias.
+    uv run export-scene g1 --output-dir /tmp/g1
+
+    # Export a registered task scene.
+    uv run export-scene Mjlab-Velocity-Flat-Unitree-Go1 --output-dir /tmp/task
+
+    # Export as a zip archive.
+    uv run export-scene yam --output-dir /tmp/yam --zip True
+
+    # Export a custom entity via import path.
+    uv run export-scene my_pkg.robots:get_my_robot_cfg --output-dir /tmp/custom
+
+The output directory contains a ``scene.xml`` and an ``assets/`` subdirectory
+with all referenced mesh files. The XML can be loaded directly with
+``mujoco.MjModel.from_xml_path()`` or dropped into the
+`simulate viewer <https://mujoco.readthedocs.io/en/stable/programming/samples.html#sasimulate>`_.
+
+Target resolution
+-----------------
+
+The positional ``target`` argument is resolved in order:
+
+1. **Task ID**: checked against the task registry (``import mjlab.tasks``).
+2. **Entity alias**: one of the built-in shorthands (``g1``, ``go1``, ``yam``).
+3. **Import path**: a ``module:attribute`` string pointing to any callable
+   that returns an ``EntityCfg``.
+
+If none match, the script prints available task IDs and aliases.
+
+Options
+-------
+
+``--output-dir DIR`` *(default: "export")*
+    Destination directory. Cleaned before each export to prevent stale assets.
+
+``--zip True`` *(default: False)*
+    Compress the output into a ``.zip`` archive and remove the directory.
diff --git a/docs/source/debugging/nan_guard.rst b/docs/source/debugging/nan_guard.rst
new file mode 100644
index 0000000..c096802
--- /dev/null
+++ b/docs/source/debugging/nan_guard.rst
@@ -0,0 +1,145 @@
+.. _nan-guard:
+
+NaN Guard
+=========
+
+The NaN guard captures simulation states when NaN/Inf is detected, helping
+debug numerical instability issues.
+
+
+Quick start
+-----------
+
+Enable the NaN guard with a single CLI flag:
+
+.. code-block:: bash
+
+    uv run train <task-name> --enable-nan-guard True
+
+This automatically captures and saves simulation states when NaN/Inf is
+detected. You can also enable it programmatically:
+
+.. code-block:: python
+
+    from mjlab.sim.sim import SimulationCfg
+    from mjlab.utils.nan_guard import NanGuardCfg
+
+    cfg = SimulationCfg(
+        nan_guard=NanGuardCfg(
+            enabled=True,
+            buffer_size=100,
+            output_dir="/tmp/mjlab/nan_dumps",
+            max_envs_to_dump=5,
+        ),
+    )
+
+
+Configuration
+-------------
+
+``enabled`` *(default: False)*
+    Enable/disable NaN detection and dumping.
+
+``buffer_size`` *(default: 100)*
+    Number of recent simulation states to keep in the rolling buffer.
+
+``output_dir`` *(default: "/tmp/mjlab/nan_dumps")*
+    Directory where NaN dump files are saved.
+
+``max_envs_to_dump`` *(default: 5)*
+    Maximum number of NaN environments to dump to disk. All environments are
+    tracked in the buffer, but only the first N are saved to reduce dump
+    size.
+
+
+Behavior
+--------
+
+- **Captures** simulation state before each step (``qpos``, ``qvel``,
+  ``act`` if the model has actuator activations, and ``mocap_pos``/``mocap_quat``
+  if the model has mocap bodies)
+- **Detects** NaN/Inf in ``qpos``, ``qvel``, ``qacc``,
+  ``qacc_warmstart``, and ``sensordata`` after each step
+- **Dumps** the rolling buffer and model to disk on first detection
+- **Stops** after the first dump to avoid spam
+
+When disabled, all operations are no-ops with negligible overhead.
+
+
+Output format
+-------------
+
+Each NaN detection creates timestamped files plus latest symlinks:
+
+- ``nan_dump_TIMESTAMP.npz``: compressed state buffer
+
+  - ``states_step_NNNNNN``: captured states per step
+    (shape: ``[num_envs_dumped, state_size]``)
+  - ``_metadata``: dict with ``num_envs_total``, ``nan_env_ids``,
+    ``dumped_env_ids``, etc.
+
+- ``model_TIMESTAMP.mjb``: MuJoCo model in binary format
+- ``nan_dump_latest.npz``: symlink to most recent dump
+- ``model_latest.mjb``: symlink to most recent model
+
+
+Visualizing dumps
+-----------------
+
+Use the interactive viewer to scrub through captured states:
+
+.. code-block:: bash
+
+    # View latest dump.
+    uv run viz-nan /tmp/mjlab/nan_dumps/nan_dump_latest.npz
+
+    # View a specific dump.
+    uv run viz-nan /tmp/mjlab/nan_dumps/nan_dump_20251014_123456.npz
+
+
+.. figure:: ../_static/content/nan_debug.gif
+   :alt: NaN Debug Viewer
+
+   NaN debug viewer.
+
+The viewer provides:
+
+- Step slider to scrub through the buffer
+- Environment slider to compare different environments
+- Info panel showing which environments have NaN/Inf
+- 3D visualization of the robot and terrain at each state
+
+
+NaN detection termination
+-------------------------
+
+While the NaN guard helps **debug** NaN issues by capturing states, you can
+also **prevent** training crashes using the ``nan_detection`` termination
+term. This marks NaN environments as terminated, allowing them to reset
+while training continues:
+
+.. code-block:: python
+
+    from mjlab.envs.mdp.terminations import nan_detection
+    from mjlab.managers.termination_manager import TerminationTermCfg
+
+    nan_term: TerminationTermCfg = field(
+        default_factory=lambda: TerminationTermCfg(
+            func=nan_detection,
+            time_out=False,
+        )
+    )
+
+Terminations are logged as ``Episode_Termination/nan_term`` in your metrics.
+
+.. important::
+
+   ``nan_detection`` is a band-aid, not a cure. If NaNs occur during your
+   task objective (e.g., NaNs happen when grasping), the policy will never
+   learn to complete the task since it resets before receiving rewards.
+   Monitor your ``Episode_Termination/nan_term`` metrics carefully.
+
+**When to use which:**
+
+- ``nan_guard``: debug and understand why NaNs occur (always do this first)
+- ``nan_detection``: keep training stable while working on a permanent fix
diff --git a/docs/source/entity/entity_data.rst b/docs/source/entity/entity_data.rst
new file mode 100644
index 0000000..e554dba
--- /dev/null
+++ b/docs/source/entity/entity_data.rst
@@ -0,0 +1,507 @@
+.. _entity_data:
+
+Entity Data
+===========
+
+This page is the property reference for ``EntityData``. For an overview
+of how ``entity.data`` fits into the broader data access story, see
+:ref:`entity`.
+
+All properties are PyTorch tensors backed by MuJoCo Warp's GPU buffers
+with no copy overhead. The first dimension is always ``num_envs``, the
+number of parallel simulation worlds.
+
+.. warning::
+
+   Read properties reflect the state after ``sim.forward()`` is called.
+   If you write simulation state and then read a derived property in the
+   same event term, call ``sim.forward()`` between the write and the
+   read. The environment step sequence already does this; the warning
+   applies only when writing custom event terms that mix reads and
+   writes. See the :ref:`FAQ <faq-sim-forward>` for a detailed
+   explanation.
+
+
+Reference: root state
+---------------------
+
+Root properties describe the position, orientation, and velocity of the
+entity's root body. Properties ending in ``_w`` are expressed in the world
+frame. Properties ending in ``_b`` are expressed in the entity's base frame.
+See :ref:`frame-conventions` for details.
+
+Each entity has two root reference points: the **link origin** (the body
+frame origin defined in the MJCF) and the **center of mass (COM)**.
+Which one is relevant depends on the task.
+
+.. admonition:: MuJoCo's mixed-frame ``qvel``
+
+   For floating-base entities, the free joint stores 6 DOFs in
+   ``qvel``. MuJoCo expresses the **linear** components in the
+   **world frame** but the **angular** components in the **local body
+   frame**. EntityData avoids this pitfall: all ``_w`` velocity
+   properties are computed from ``cvel`` (see
+   :ref:`cvel-section` below) and are fully world-frame. If you
+   read ``env.sim.data.qvel`` directly, be aware of the mixed
+   convention.
+
+.. rubric:: Root link properties
+
+.. list-table::
+   :header-rows: 1
+   :widths: 35 20 15 30
+
+   * - Property
+     - Shape
+     - Frame
+     - Description
+   * - ``root_link_pose_w``
+     - ``[num_envs, 7]``
+     - world
+     - Root link position (3) and quaternion (4) concatenated
+   * - ``root_link_pos_w``
+     - ``[num_envs, 3]``
+     - world
+     - Root link position
+   * - ``root_link_quat_w``
+     - ``[num_envs, 4]``
+     - world
+     - Root link orientation as quaternion (w, x, y, z)
+   * - ``root_link_vel_w``
+     - ``[num_envs, 6]``
+     - world
+     - Root link linear (3) and angular (3) velocity concatenated
+   * - ``root_link_lin_vel_w``
+     - ``[num_envs, 3]``
+     - world
+     - Root link linear velocity
+   * - ``root_link_ang_vel_w``
+     - ``[num_envs, 3]``
+     - world
+     - Root link angular velocity
+   * - ``root_link_lin_vel_b``
+     - ``[num_envs, 3]``
+     - body
+     - Root link linear velocity in base frame
+   * - ``root_link_ang_vel_b``
+     - ``[num_envs, 3]``
+     - body
+     - Root link angular velocity in base frame
+
+.. rubric:: Root COM properties
+
+.. list-table::
+   :header-rows: 1
+   :widths: 35 20 15 30
+
+   * - Property
+     - Shape
+     - Frame
+     - Description
+   * - ``root_com_pose_w``
+     - ``[num_envs, 7]``
+     - world
+     - Root COM position (3) and quaternion (4) concatenated
+   * - ``root_com_pos_w``
+     - ``[num_envs, 3]``
+     - world
+     - Root COM position
+   * - ``root_com_quat_w``
+     - ``[num_envs, 4]``
+     - world
+     - Root COM orientation as quaternion (w, x, y, z)
+   * - ``root_com_vel_w``
+     - ``[num_envs, 6]``
+     - world
+     - Root COM linear (3) and angular (3) velocity concatenated
+   * - ``root_com_lin_vel_w``
+     - ``[num_envs, 3]``
+     - world
+     - Root COM linear velocity
+   * - ``root_com_ang_vel_w``
+     - ``[num_envs, 3]``
+     - world
+     - Root COM angular velocity
+   * - ``root_com_lin_vel_b``
+     - ``[num_envs, 3]``
+     - body
+     - Root COM linear velocity in base frame
+   * - ``root_com_ang_vel_b``
+     - ``[num_envs, 3]``
+     - body
+     - Root COM angular velocity in base frame
+
+.. rubric:: Derived root properties
+
+.. list-table::
+   :header-rows: 1
+   :widths: 35 20 15 30
+
+   * - Property
+     - Shape
+     - Frame
+     - Description
+   * - ``projected_gravity_b``
+     - ``[num_envs, 3]``
+     - body
+     - Gravity vector (0, 0, -1) rotated into the base frame. Used to measure
+       tilt: a perfectly upright robot reads ``[0, 0, -1]``.
+   * - ``heading_w``
+     - ``[num_envs]``
+     - world
+     - Heading angle (radians) of the root body's forward axis projected onto
+       the XY plane.
+
+
+Reference: body state
+---------------------
+
+Body properties give per-body kinematic state for all bodies belonging to the
+entity. The second dimension is ``num_bodies``, which counts all non-world
+bodies in the entity's kinematic tree.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 35 25 15 25
+
+   * - Property
+     - Shape
+     - Frame
+     - Description
+   * - ``body_link_pose_w``
+     - ``[num_envs, num_bodies, 7]``
+     - world
+     - Per-body link position (3) and quaternion (4)
+   * - ``body_link_pos_w``
+     - ``[num_envs, num_bodies, 3]``
+     - world
+     - Per-body link positions
+   * - ``body_link_quat_w``
+     - ``[num_envs, num_bodies, 4]``
+     - world
+     - Per-body link orientations
+   * - ``body_link_vel_w``
+     - ``[num_envs, num_bodies, 6]``
+     - world
+     - Per-body link linear (3) and angular (3) velocity
+   * - ``body_link_lin_vel_w``
+     - ``[num_envs, num_bodies, 3]``
+     - world
+     - Per-body link linear velocities
+   * - ``body_link_ang_vel_w``
+     - ``[num_envs, num_bodies, 3]``
+     - world
+     - Per-body link angular velocities
+   * - ``body_com_pose_w``
+     - ``[num_envs, num_bodies, 7]``
+     - world
+     - Per-body COM position (3) and quaternion (4)
+   * - ``body_com_pos_w``
+     - ``[num_envs, num_bodies, 3]``
+     - world
+     - Per-body COM positions
+   * - ``body_com_quat_w``
+     - ``[num_envs, num_bodies, 4]``
+     - world
+     - Per-body COM orientations
+   * - ``body_com_vel_w``
+     - ``[num_envs, num_bodies, 6]``
+     - world
+     - Per-body COM linear (3) and angular (3) velocity
+   * - ``body_com_lin_vel_w``
+     - ``[num_envs, num_bodies, 3]``
+     - world
+     - Per-body COM linear velocities
+   * - ``body_com_ang_vel_w``
+     - ``[num_envs, num_bodies, 3]``
+     - world
+     - Per-body COM angular velocities
+   * - ``body_external_wrench``
+     - ``[num_envs, num_bodies, 6]``
+     - world
+     - External force (3) and torque (3) applied to each body
+   * - ``body_external_force``
+     - ``[num_envs, num_bodies, 3]``
+     - world
+     - External forces applied to each body
+   * - ``body_external_torque``
+     - ``[num_envs, num_bodies, 3]``
+     - world
+     - External torques applied to each body
+
+
+Reference: joint state
+----------------------
+
+Joint properties cover 1-DOF revolute and prismatic joints. The free joint
+(root floating-base DOF) is excluded; use root state properties for that.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 35 25 40
+
+   * - Property
+     - Shape
+     - Description
+   * - ``joint_pos``
+     - ``[num_envs, num_joints]``
+     - Joint positions in radians (revolute) or metres (prismatic)
+   * - ``joint_pos_biased``
+     - ``[num_envs, num_joints]``
+     - Joint positions with encoder bias added. Used when simulating
+       encoder calibration errors via domain randomization.
+   * - ``joint_vel``
+     - ``[num_envs, num_joints]``
+     - Joint velocities in rad/s or m/s
+   * - ``joint_acc``
+     - ``[num_envs, num_joints]``
+     - Joint accelerations in rad/s² or m/s²
+   * - ``actuator_force``
+     - ``[num_envs, num_actuators]``
+     - Scalar actuator output in actuation space (per actuator). This is
+       the force before projection through the transmission Jacobian. For
+       actuator forces in joint space, use ``qfrc_actuator`` instead.
+
+
+.. _generalized-forces:
+
+Reference: generalized forces
+-----------------------------
+
+These properties expose selected components of MuJoCo's generalized
+force decomposition, sliced to this entity's articulated joint DOFs.
+Free joint DOFs are excluded. All shapes are ``[num_envs, nv]`` where
+``nv`` is the number of articulated DOFs belonging to this entity.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 70
+
+   * - Property
+     - Description
+   * - ``qfrc_actuator``
+     - Forces produced by all actuators, mapped into joint space. For
+       motors this is the commanded torque times the gear ratio. For
+       position and velocity actuators this is the force computed by
+       the internal PD law. When ``actuatorgravcomp`` is enabled on a
+       joint, the gravity compensation force is included here.
+   * - ``qfrc_external``
+     - Forces on joints due to Cartesian wrenches applied to bodies
+       via ``xfrc_applied``. This is the :math:`J^\top F` mapping.
+       MuJoCo does not store this term separately; the property
+       recovers it from other force components after ``forward()``.
+
+Reference: geom and site state
+-------------------------------
+
+.. list-table::
+   :header-rows: 1
+   :widths: 35 25 40
+
+   * - Property
+     - Shape
+     - Description
+   * - ``geom_pose_w``
+     - ``[num_envs, num_geoms, 7]``
+     - Per-geom position (3) and quaternion (4) in world frame
+   * - ``geom_pos_w``
+     - ``[num_envs, num_geoms, 3]``
+     - Per-geom positions in world frame
+   * - ``geom_quat_w``
+     - ``[num_envs, num_geoms, 4]``
+     - Per-geom orientations in world frame
+   * - ``geom_vel_w``
+     - ``[num_envs, num_geoms, 6]``
+     - Per-geom linear (3) and angular (3) velocity in world frame
+   * - ``geom_lin_vel_w``
+     - ``[num_envs, num_geoms, 3]``
+     - Per-geom linear velocities in world frame
+   * - ``geom_ang_vel_w``
+     - ``[num_envs, num_geoms, 3]``
+     - Per-geom angular velocities in world frame
+   * - ``site_pose_w``
+     - ``[num_envs, num_sites, 7]``
+     - Per-site position (3) and quaternion (4) in world frame
+   * - ``site_pos_w``
+     - ``[num_envs, num_sites, 3]``
+     - Per-site positions in world frame
+   * - ``site_quat_w``
+     - ``[num_envs, num_sites, 4]``
+     - Per-site orientations in world frame
+   * - ``site_vel_w``
+     - ``[num_envs, num_sites, 6]``
+     - Per-site linear (3) and angular (3) velocity in world frame
+   * - ``site_lin_vel_w``
+     - ``[num_envs, num_sites, 3]``
+     - Per-site linear velocities in world frame
+   * - ``site_ang_vel_w``
+     - ``[num_envs, num_sites, 3]``
+     - Per-site angular velocities in world frame
+
+
+Reference: tendon state
+-----------------------
+
+Tendon properties are only populated for entities that have tendon-driven
+actuators.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 35 25 40
+
+   * - Property
+     - Shape
+     - Description
+   * - ``tendon_len``
+     - ``[num_envs, num_tendons]``
+     - Tendon lengths
+   * - ``tendon_vel``
+     - ``[num_envs, num_tendons]``
+     - Tendon velocities
+
+
+.. _frame-conventions:
+
+Frame conventions
+-----------------
+
+Property names encode their reference frame with a suffix.
+
+``_w`` (world frame)
+    A fixed global frame. The origin is typically at the scene origin and
+    its axes are constant throughout the episode. World-frame quantities are
+    useful when you need absolute position, such as checking whether the
+    robot has fallen below a height threshold.
+
+``_b`` (body frame / base frame)
+    The entity's root body frame. It translates and rotates with the robot.
+    Most observation terms use body-frame quantities because they are
+    invariant to the robot's heading direction. A velocity expressed in the
+    body frame reads the same whether the robot faces north or south, which
+    makes it easier for the policy to generalize.
+
+``projected_gravity_b`` is a good example of why the frame suffix
+matters. It takes the world-frame gravity vector ``[0, 0, -1]`` and
+rotates it into the base frame. When the robot is upright the result is
+``[0, 0, -1]``; as the robot tilts, the x and y components grow,
+giving the policy a direct signal for orientation correction.
+
+Quaternion convention
+^^^^^^^^^^^^^^^^^^^^^
+
+All quaternions use the ``(w, x, y, z)`` convention, matching MuJoCo.
+
+Reduced state vs. derived quantities
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+EntityData properties fall into two categories that behave differently
+with respect to ``sim.forward()``:
+
+**Reduced state.** ``joint_pos`` and ``joint_vel`` read directly from
+MuJoCo's ``qpos`` and ``qvel`` arrays. Write methods such as
+``write_joint_state_to_sim()`` modify these arrays directly, so reads
+are always current.
+
+**Derived quantities.** All pose and velocity properties (``*_pose_w``,
+``*_vel_w``, ``*_vel_b``) are computed from MuJoCo's internal arrays
+(``xpos``, ``xquat``, ``cvel``, ``subtree_com``, etc.) which are only
+updated when ``sim.forward()`` runs. If you write to ``qpos``/``qvel``
+and then read a derived property without an intervening ``forward()``,
+the read will return stale values.
+
+The environment step sequence calls ``forward()`` at the right time, so
+this only matters if you write custom event terms that both write and
+read in the same function. See the :ref:`FAQ <faq-sim-forward>` for
+details.
+
+.. _cvel-section:
+
+How velocity properties are computed from ``cvel``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+MuJoCo does not store world-frame linear velocities directly. Instead,
+it stores a 6D spatial velocity per body called ``cvel`` (com-based
+velocity), laid out as ``(angular[3], linear[3])``. This vector is
+expressed in the **c-frame**: a frame centered at ``subtree_com`` (the
+center of mass of the body's kinematic subtree) and oriented like the
+world frame. MuJoCo uses this representation to improve numerical
+precision for mechanisms far from the world origin. See
+`c-frame variables <https://mujoco.readthedocs.io/en/stable/APIreference/APItypes.html#c-frame-variables>`_
+and Featherstone's
+`Spatial Algebra <http://royfeatherstone.org/spatial/>`_ for background.
+
+To recover the world-frame linear velocity at an arbitrary point
+:math:`\mathbf{p}` on a rigid body, we apply the standard rigid-body
+velocity transfer formula. Let :math:`\boldsymbol{\omega}` and
+:math:`\mathbf{v}_c` denote the angular and linear components of
+``cvel``, and let :math:`\mathbf{c}` denote ``subtree_com``. Because
+the c-frame is world-aligned, :math:`\boldsymbol{\omega}` is already in
+the world frame. The linear velocity at :math:`\mathbf{p}` is:
+
+.. math::
+
+   \mathbf{v}_p
+     = \mathbf{v}_c
+       - \boldsymbol{\omega} \times (\mathbf{c} - \mathbf{p})
+
+EntityData applies this formula in ``compute_velocity_from_cvel()``:
+
+.. code-block:: python
+
+   def compute_velocity_from_cvel(pos, subtree_com, cvel):
+       lin_vel_c = cvel[..., 3:6]
+       ang_vel_c = cvel[..., 0:3]
+       offset = subtree_com - pos
+       lin_vel_w = lin_vel_c - torch.cross(ang_vel_c, offset, dim=-1)
+       ang_vel_w = ang_vel_c
+       return torch.cat([lin_vel_w, ang_vel_w], dim=-1)
+
+Every velocity property in EntityData (``root_link_vel_w``,
+``body_link_vel_w``, ``geom_vel_w``, ``site_vel_w``, and their COM
+variants) uses this function, substituting the appropriate point:
+
+- **Link velocities** use ``xpos`` (body frame origin).
+- **COM velocities** use ``xipos`` (body center of mass).
+- **Geom/site velocities** use ``geom_xpos``/``site_xpos``, with
+  ``cvel`` looked up from the parent body.
+
+
+Default pose and relative quantities
+--------------------------------------
+
+``entity.data.default_joint_pos`` holds the joint positions from the entity's
+initial-state configuration (the ``init_state.joint_pos`` field of
+``EntityCfg``). It has shape ``[num_envs, num_joints]`` and is replicated
+across all environments at initialization time.
+
+The relative joint position is the deviation of the current joint position
+from this default:
+
+.. code-block:: python
+
+    joint_pos_rel = joint_pos - default_joint_pos
+
+This is what the ``joint_pos_rel`` observation function computes:
+
+.. code-block:: python
+
+    def joint_pos_rel(env, asset_cfg):
+        asset = env.scene[asset_cfg.name]
+        jnt_ids = asset_cfg.joint_ids
+        return (
+            asset.data.joint_pos[:, jnt_ids]
+            - asset.data.default_joint_pos[:, jnt_ids]
+        )
+
+Relative joint positions give the policy a compact representation of posture
+deviation. When the robot is at its default pose, every element is zero.
+
+Similarly, ``default_joint_vel`` is used by the ``joint_vel_rel`` observation
+function. For most configurations the default velocity is zero, so
+``joint_vel_rel`` is identical to ``joint_vel``. The indirection exists to
+allow non-zero reference velocities in tasks such as motion imitation.
+
+The ``use_default_offset=True`` option in joint position action configs uses
+``default_joint_pos`` as the zero point for the action space, so a network
+output of zero commands the robot to its default pose. This is the standard
+configuration for locomotion tasks.
diff --git a/docs/source/entity/index.rst b/docs/source/entity/index.rst
new file mode 100644
index 0000000..de658ab
--- /dev/null
+++ b/docs/source/entity/index.rst
@@ -0,0 +1,355 @@
+.. _entity:
+
+Entity
+======
+
+An ``Entity`` represents a physical object in the simulation: a robot, a
+manipulated object, or a fixed fixture like a table. It is the central
+abstraction in mjlab's physics layer.
+
+A single ``Entity`` class covers all variants (contrast Isaac Lab, which
+splits this across ``Articulation``, ``RigidObject``, and several other
+subclasses of ``AssetBase``). Two orthogonal boolean properties classify
+each instance:
+
+**Base type.**
+  A *fixed-base* entity is welded to the world and has no free joint. A
+  *floating-base* entity has a free joint giving it 6-DOF movement.
+
+**Articulation.**
+  An *articulated* entity has internal joints (revolute, prismatic, etc.).
+  A *non-articulated* entity has none beyond a possible free joint.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 25 15 15 15
+
+   * - Type
+     - Example
+     - ``is_fixed_base``
+     - ``is_articulated``
+     - ``is_actuated``
+   * - Fixed non-articulated
+     - Table, wall
+     - True
+     - False
+     - False
+   * - Fixed articulated
+     - Robot arm, door
+     - True
+     - True
+     - True/False
+   * - Floating non-articulated
+     - Box, ball, mug
+     - False
+     - False
+     - False
+   * - Floating articulated
+     - Humanoid, quadruped
+     - False
+     - True
+     - True/False
+
+.. note::
+
+   mjlab automatically wraps every fixed-base entity in a
+   `mocap body <https://mujoco.readthedocs.io/en/stable/modeling.html#mocap-bodies>`_
+   so that each parallel environment can place the entity at a different
+   position. Without this wrapping, all fixed-base entities would be
+   welded to the world origin. The wrapping is transparent, but
+   **positioning only happens when a reset event runs**. You must
+   include a reset event such as ``reset_root_state_uniform`` in your
+   event config; without one, every fixed-base entity will remain at
+   the origin. See the :ref:`FAQ <faq>` for a full example. Mocap
+   entities can also be repositioned at runtime via
+   ``entity.write_mocap_pose_to_sim()``.
+
+
+Configuring an entity
+---------------------
+
+Every entity is described by an ``EntityCfg``. Only ``spec_fn`` is
+required in practice; all other fields have sensible defaults. A passive
+floating object needs nothing more than:
+
+.. code-block:: python
+
+    from mjlab.entity import EntityCfg
+
+    cube_cfg = EntityCfg(spec_fn=get_cube_spec)
+
+An actuated robot uses more of the interface:
+
+.. code-block:: python
+
+    from mjlab.entity import EntityCfg, EntityArticulationInfoCfg
+    from mjlab.actuator import IdealPDActuatorCfg
+
+    robot_cfg = EntityCfg(
+        spec_fn=get_spec,
+        init_state=EntityCfg.InitialStateCfg(
+            pos=(0.0, 0.0, 0.8),
+            joint_pos={".*_hip_.*": 0.5, ".*": 0.0},
+        ),
+        articulation=EntityArticulationInfoCfg(
+            actuators=(
+                IdealPDActuatorCfg(
+                    target_names_expr=(".*",),
+                    stiffness={".*": 50.0},
+                    damping={".*": 5.0},
+                ),
+            ),
+        ),
+        collisions=(my_collision_cfg,),
+    )
+
+The following sections describe each field.
+
+``spec_fn``
+^^^^^^^^^^^
+
+A callable that returns an ``mujoco.MjSpec``. The scene calls it during
+composition, attaches the returned spec with a name prefix, and compiles
+everything into a shared ``MjModel``.
+
+For simple cases a lambda suffices:
+
+.. code-block:: python
+
+    spec_fn = lambda: mujoco.MjSpec.from_file("robot.xml")
+
+For anything more involved, use a regular function. MuJoCo resolves mesh
+assets from disk automatically, so ``get_spec`` only needs to load the
+XML:
+
+.. code-block:: python
+
+    def get_spec() -> mujoco.MjSpec:
+        return mujoco.MjSpec.from_file(str(ROBOT_XML))
+
+Because ``spec_fn`` is an arbitrary callable, you can perform any
+`MjSpec edits <https://mujoco.readthedocs.io/en/stable/python.html#spec>`_
+before returning: add bodies, change joint limits, swap materials,
+or build the entire model programmatically without an XML file at all.
+
+``init_state``
+^^^^^^^^^^^^^^
+
+Default root pose, root velocity, and joint positions/velocities. These
+values are stored as a MuJoCo keyframe and used by reset events to
+return the entity to its initial configuration.
+
+``joint_pos`` and ``joint_vel`` are dicts mapping regex patterns to
+values. Patterns are matched against joint names in order, so later
+entries override earlier ones for any joint that matches both:
+
+.. code-block:: python
+
+    init_state = EntityCfg.InitialStateCfg(
+        pos=(0.0, 0.0, 0.8),       # root position
+        rot=(1.0, 0.0, 0.0, 0.0),  # root quaternion (w, x, y, z)
+        joint_pos={
+            ".*": 0.0,              # all joints to zero
+            ".*_hip_.*": 0.5,       # then override hips to 0.5
+        },
+    )
+
+Set ``joint_pos=None`` to use an existing keyframe from the MJCF model
+instead of defining values here.
+
+``articulation``
+^^^^^^^^^^^^^^^^
+
+Actuator configuration. Only needed for entities that have actuated
+joints. Passive objects (boxes, tables, walls) can omit this field
+entirely. See :ref:`actuators` for details on actuator types.
+
+``soft_joint_pos_limit_factor`` (default 1.0) shrinks the joint range
+used by soft-limit penalty rewards, so the policy is penalized before
+reaching the physical hard stop. This does not modify the actual joint
+limits in the MuJoCo model.
+
+Spec editors
+^^^^^^^^^^^^
+
+The remaining fields are optional tuples of spec editor configs that
+modify the ``MjSpec`` before compilation:
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 80
+
+   * - Field
+     - Purpose
+   * - ``collisions``
+     - Replace the entity's collision structure: which geoms collide, and
+       with what contact parameters.
+   * - ``lights``
+     - Add lights to specific bodies.
+   * - ``cameras``
+     - Add cameras to specific bodies.
+   * - ``textures``
+     - Add procedural textures (checker, gradient, etc.).
+   * - ``materials``
+     - Add materials and optionally assign them to geoms by regex.
+   * - ``geoms``
+     - Patch attributes of existing geoms (visualization group, collision
+       attributes). Unset attributes are left untouched.
+
+Each editor accepts regex patterns to target specific elements. For
+example, a ``CollisionCfg`` with ``geom_names_expr=(".*_foot.*",)``
+sets contact parameters only on foot geoms. See the asset zoo
+(``mjlab.asset_zoo.robots``) for complete examples.
+
+``geoms`` and ``collisions`` both write geom attributes but with
+different semantics. A ``GeomCfg`` is a sparse *patch*: every attribute
+defaults to ``None``, and only attributes you set are written. A
+``CollisionCfg`` is a *policy*: ``contype``, ``conaffinity``,
+``condim``, and ``priority`` are required and always written to every
+matched geom, and non-matched geoms have collision disabled by default,
+so the entity's contact behavior is fully determined by the config
+regardless of the source XML. Collision configs are applied after geom
+configs; mjlab warns if a ``GeomCfg`` sets a collision attribute that a
+``CollisionCfg`` then overwrites.
+
+Heterogeneous worlds
+^^^^^^^^^^^^^^^^^^^^
+
+For scenes that need different mesh assets in different parallel worlds
+(for example, training a manipulation policy that generalizes across
+object shapes), use ``VariantEntityCfg`` instead of ``EntityCfg``. Each
+world is assigned a variant proportional to a configurable weight, and
+mesh-dependent compiled constants (collision bounds, body inertials,
+subtree mass) are stored as per-world arrays so domain randomization and
+viewers stay consistent. See :ref:`heterogeneous_worlds`.
+
+Subclassing Entity
+^^^^^^^^^^^^^^^^^^
+
+``Entity`` and ``EntityCfg`` can be subclassed for specialized behavior.
+mjlab itself does this for terrain: ``TerrainEntity`` extends ``Entity``
+with procedural terrain generation and per-environment origin
+computation, and ``TerrainEntityCfg`` adds fields like
+``terrain_type``, ``env_spacing``, and ``terrain_generator``. The same
+pattern works for any domain-specific entity that needs logic beyond
+what ``EntityCfg`` and spec editors provide.
+
+Finding elements
+^^^^^^^^^^^^^^^^
+
+Entity provides ``find_*`` methods that accept regex patterns and return
+matched element indices and names:
+
+.. code-block:: python
+
+    ids, names = entity.find_joints((".*_hip_.*", ".*_knee_.*"))
+    ids, names = entity.find_geoms((".*foot.*",))
+    ids, names = entity.find_bodies((".*",))
+
+Available methods: ``find_bodies()``, ``find_joints()``,
+``find_geoms()``, ``find_sites()``, ``find_tendons()``.
+These are used internally during scene construction and manager
+initialization. In reward and observation terms, prefer
+``SceneEntityCfg`` with name patterns as described below.
+
+
+Reading runtime state
+---------------------
+
+Once entities are added to a ``SceneCfg`` and the environment is
+constructed, their state is accessible through three interfaces at
+decreasing levels of abstraction.
+
+EntityData
+^^^^^^^^^^
+
+``entity.data`` is the primary interface for reward, observation, and
+termination functions. It exposes kinematic state (poses, velocities, accelerations), actuator forces,
+generalized forces, and derived body-frame quantities such as projected
+gravity, all as PyTorch tensors with
+shape ``(num_envs, ...)``. See :ref:`entity_data` for the full property
+reference.
+
+``SceneEntityCfg`` selects which entity and which elements within it a
+term operates on. Regex patterns in ``joint_names``, ``body_names``,
+``site_names``, etc. are resolved to integer indices once at manager
+initialization, so there is no regex overhead at runtime:
+
+.. code-block:: python
+
+    from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+    def flat_orientation_l2(
+        env,
+        asset_cfg: SceneEntityCfg = SceneEntityCfg("robot"),
+    ) -> torch.Tensor:
+        """Penalize non-flat base orientation using projected gravity."""
+        asset = env.scene[asset_cfg.name]
+        return torch.sum(
+            torch.square(asset.data.projected_gravity_b[:, :2]), dim=1
+        )
+
+``SceneEntityCfg`` also supports regex element selection through
+``joint_names``, ``body_names``, ``site_names``, etc. The resolved
+integer indices (e.g., ``asset_cfg.joint_ids``) make the runtime read a
+single tensor slice with no regex overhead.
+
+Sensors
+^^^^^^^
+
+Sensors are configured on the **scene**, not on individual entities.
+A sensor can reference an entity element (e.g., a contact sensor on the
+robot's feet, an accelerometer attached to a body site), but it can also
+be independent of any entity. This is why sensors live in ``SceneCfg``
+rather than ``EntityCfg``.
+
+At runtime, sensors are accessed by name through ``env.scene``, the same
+way entities are:
+
+.. code-block:: python
+
+    def angular_momentum_penalty(env, sensor_name: str) -> torch.Tensor:
+        sensor = env.scene[sensor_name]
+        return torch.sum(torch.square(sensor.data), dim=-1)
+
+Builtin sensors wrap MuJoCo sensor types (accelerometer, gyro, framepos,
+subtreeangmom, etc.). ``ContactSensor``, ``RayCastSensor``, and
+``CameraSensor`` provide higher-level abstractions for contact detection,
+terrain scanning, and RGB-D rendering. See :ref:`sensors` for details.
+
+Raw simulation data
+^^^^^^^^^^^^^^^^^^^
+
+For anything not covered by ``EntityData`` or sensors, the underlying
+MuJoCo Warp arrays are accessible through ``env.sim.data`` and
+``env.sim.model``. These expose the full ``mjData`` and ``mjModel``
+fields as PyTorch tensors (zero-copy), indexed by global MuJoCo IDs
+rather than per-entity IDs:
+
+.. code-block:: python
+
+    # Global joint positions across all entities.
+    qpos = env.sim.data.qpos          # (num_envs, nq)
+
+    # All body positions.
+    xpos = env.sim.data.xpos          # (num_envs, nbody, 3)
+
+    # Model-level constants.
+    body_mass = env.sim.model.body_mass  # (nbody,)
+
+This is useful for low-level operations or when you need quantities
+that span multiple entities.
+
+.. note::
+
+   The main limitation of raw sim data is that you must manage global
+   MuJoCo indices yourself. In the future, we plan to support MuJoCo's
+   `bind <https://mujoco.readthedocs.io/en/latest/python.html#relationship-to-pymjcf-and-bind>`_
+   functionality, which will allow binding spec elements directly to
+   their corresponding data views without manual index bookkeeping.
+
+.. toctree::
+   :maxdepth: 1
+
+   entity_data
+   per_world_mesh
diff --git a/docs/source/entity/per_world_mesh.rst b/docs/source/entity/per_world_mesh.rst
new file mode 100644
index 0000000..0aa89c2
--- /dev/null
+++ b/docs/source/entity/per_world_mesh.rst
@@ -0,0 +1,490 @@
+.. _heterogeneous_worlds:
+
+Heterogeneous Worlds
+====================
+
+mjlab can run a single batched simulation in which different parallel
+worlds use different mesh assets for the same logical entity. World 0
+may simulate a cube, world 1 a sphere, world 2 a bowl. All worlds
+share the same compiled scene and the same body and joint structure;
+only the meshes and the per-geom attributes that travel with them
+(friction, contact bits, mass, density, and a few more) differ across
+worlds. Articulated props work too (you can have a hinge or slide
+below the variant's root), as long as the joint topology matches
+across variants. The feature is exposed through ``VariantEntityCfg``.
+The full breakdown of what can and cannot vary across variants is in
+the next section.
+
+
+Quickstart
+----------
+
+Say you want some parallel worlds to hold a sphere and others to hold
+a cone, with a single shared scene running both at once. Define each
+variant as a function that returns an ``MjSpec``, then group them
+under one ``VariantEntityCfg``:
+
+.. code-block:: python
+
+    import mujoco
+
+    from mjlab.entity import EntityCfg, VariantEntityCfg
+
+
+    def make_sphere_spec() -> mujoco.MjSpec:
+        spec = mujoco.MjSpec()
+        mesh = spec.add_mesh(name="visual")
+        mesh.make_sphere(subdivision=3)
+        mesh.scale[:] = (0.05,) * 3
+        body = spec.worldbody.add_body(name="prop")
+        body.add_freejoint()
+        body.add_geom(type=mujoco.mjtGeom.mjGEOM_MESH, meshname="visual")
+        return spec
+
+
+    def make_cone_spec() -> mujoco.MjSpec:
+        spec = mujoco.MjSpec()
+        mesh = spec.add_mesh(name="visual")
+        mesh.make_cone(nedge=16, radius=0.04)
+        body = spec.worldbody.add_body(name="prop")
+        body.add_freejoint()
+        body.add_geom(type=mujoco.mjtGeom.mjGEOM_MESH, meshname="visual")
+        return spec
+
+
+    object_cfg = VariantEntityCfg(
+        variants={
+            "sphere": make_sphere_spec,
+            "cone":   make_cone_spec,
+        },
+        assignment={"cone": 2.0},  # twice as many cones as spheres
+        init_state=EntityCfg.InitialStateCfg(pos=(0.0, 0.0, 0.2)),
+    )
+
+Plug the variant entity into a :ref:`scene` exactly like a regular
+``EntityCfg``:
+
+.. code-block:: python
+
+    from mjlab.scene import SceneCfg
+
+    scene_cfg = SceneCfg(
+        num_envs=4096,
+        entities={"object": object_cfg},
+    )
+
+Twice as many worlds will hold a cone as a sphere. Variants not listed
+in the ``assignment`` dict default to weight 1.0; omit ``assignment``
+entirely for uniform allocation across all variants.
+
+
+What variants can differ in
+---------------------------
+
+**Free to vary across variants:** the mesh asset assigned to each
+slot, the number of mesh geoms per ``(body, role)`` bucket on the
+variant body (one variant can have more collision meshes than
+another), the per-mesh-geom attributes that travel with the mesh
+(friction, contact bits, mass, density, ``condim``, and a handful of
+others), and explicit body inertial values within whichever single
+inertial mode the variants agree on per body.
+
+**Must match across variants:** the body tree, joint topology,
+primitive (non-mesh) geoms, and any actuators / sensors / tendons /
+equalities. Variants must also agree on the inertial representation
+per body (mesh-derived, diagonal, or fullinertia), and may not use the
+reserved ``mjlab/pad/`` name prefix on any element. Variant entities
+must also be floating-base: the root body declares a freejoint.
+
+The validator runs at entity build time and raises ``ValueError``
+naming the offending variant and the exact mismatch.
+
+
+How variants are assembled
+--------------------------
+
+mjlab merges every variant's mesh assets into a single ``MjSpec`` and
+gives the variant body enough mesh-geom *slots* to cover the maximum
+mesh count any variant uses for each ``(body, role)`` bucket. A slot
+is identified by ``(body_path, role, ordinal)``. ``role`` is "visual"
+or "collision", derived from ``contype``/``conaffinity``;
+mujoco_warp's ``geom_contype``/``geom_conaffinity`` are 1D shared
+(not per-world), so a slot's role is fixed across worlds by
+construction.
+
+A worked example
+~~~~~~~~~~~~~~~~
+
+Say variant ``sphere`` has 1 visual mesh geom and 2 collision mesh
+geoms on the prop body, and variant ``cone`` has 1 visual mesh geom
+and 4 collision mesh geoms on the same body.
+
+.. code-block:: text
+
+    sphere variant body              cone variant body
+    -------------------              -------------------
+    prop body                        prop body
+      [visual] sphere_vis              [visual] cone_vis
+      [coll]   sphere_col_0            [coll]   cone_col_0
+      [coll]   sphere_col_1            [coll]   cone_col_1
+                                       [coll]   cone_col_2
+                                       [coll]   cone_col_3
+
+mjlab walks each variant's body tree, buckets mesh geoms by
+``(body_path, role)``, and lays the union out as slots:
+
+.. list-table::
+   :header-rows: 1
+   :widths: 8 18 8 12 27 27
+
+   * - Slot
+     - body_path
+     - role
+     - ordinal
+     - sphere fills with
+     - cone fills with
+   * - 0
+     - /prop
+     - visual
+     - 0
+     - sphere_vis
+     - cone_vis
+   * - 1
+     - /prop
+     - collision
+     - 0
+     - sphere_col_0
+     - cone_col_0
+   * - 2
+     - /prop
+     - collision
+     - 1
+     - sphere_col_1
+     - cone_col_1
+   * - 3
+     - /prop
+     - collision
+     - 2
+     - *(unfilled)*
+     - cone_col_2
+   * - 4
+     - /prop
+     - collision
+     - 3
+     - *(unfilled)*
+     - cone_col_3
+
+Five slots total. The merged scene's prop body has five mesh geoms:
+slot 0 plus four collision slots (the union of sphere's two and
+cone's four). At merge time, every variant's mesh asset is added to
+the merged spec under a unique name (e.g.
+``sphere/sphere_vis``, ``cone/cone_col_2``).
+
+The merged scene compiles once into a single canonical ``MjModel``
+that every world in the batch agrees on layout-wise: same nbody,
+ngeom, same body and geom IDs. mjlab's per-world overrides on top of
+that one model are what make worlds heterogeneous.
+
+What each world sees at runtime
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Worlds where ``sphere`` is active see only its three meshes; the two
+extra collision slots are disabled via per-world ``geom_dataid = -1``,
+and mujoco_warp skips them. Worlds where ``cone`` is active see all
+five meshes wired up.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 14 14 12 12 12 12 12
+
+   * - World
+     - variant
+     - slot 0
+     - slot 1
+     - slot 2
+     - slot 3
+     - slot 4
+   * - 0
+     - sphere
+     - sphere_vis
+     - sphere_col_0
+     - sphere_col_1
+     - **off (-1)**
+     - **off (-1)**
+   * - 1
+     - cone
+     - cone_vis
+     - cone_col_0
+     - cone_col_1
+     - cone_col_2
+     - cone_col_3
+
+Three categories of per-world override carry the variation:
+
+* **geom_dataid** is a ``(num_envs, ngeom)`` table. Its row for
+  world W picks which compiled mesh each slot points at. ``-1`` is
+  the "skip me" sentinel mujoco_warp already understands.
+* **Mesh-derived fields** (``geom_size``, ``geom_rbound``,
+  ``geom_aabb``, ``geom_pos``, ``geom_quat``, ``body_mass``,
+  ``body_subtreemass``, ``body_inertia``, ``body_invweight0``,
+  ``body_ipos``, ``body_iquat``) are stored as ``(num_envs, ...)``
+  arrays. The values for sphere worlds reflect a sphere-shaped
+  inertia tensor and sphere-sized AABBs; the values for cone worlds
+  reflect the cone. The full list is in
+  ``mjlab.entity.variants.VARIANT_DEPENDENT_FIELDS``.
+* **Per-mesh-geom attributes** (contact bits, friction, mass,
+  density, condim, group, priority, rgba, solref, solimp, margin,
+  gap) are captured per variant in ``VariantGeomSpec`` at merge time
+  and restored verbatim on the slot geom during the per-variant
+  reference compile. So if sphere's collision geoms have
+  ``friction=0.5`` and cone's have ``friction=1.2``, world W's
+  per-step friction reflects the assigned variant's source value.
+  The one exception is ``material``, which is not propagated across
+  variants; if you need per-world appearance variation use DR on
+  ``geom_rgba`` / ``mat_rgba``.
+
+If ``sphere`` adds a body that ``cone`` lacks (or vice versa), the
+validator rejects the configuration before any of the merge logic
+runs. The slot mechanism only flexes mesh geom counts within
+matching bodies; everything structural above the geom level must
+agree.
+
+.. note::
+
+   **Doesn't compiling the merged scene ruin the prop body's
+   inertia?**
+
+   No, but it's worth understanding why, because the naive intuition
+   says it should. If you stuck every variant's mesh geoms on the
+   prop body and called ``spec.compile()``, MuJoCo would sum each
+   geom's inertial contribution, and you would get a body whose mass
+   and inertia tensor are a meaningless mix of every variant's shape.
+
+   mjlab avoids this in two layers:
+
+   * **The merged scene does not stick every variant's geoms on the
+     body.** The prop body in the merged spec carries variant 0's
+     mesh geoms (with their original mass and density) plus, for any
+     slot variant 0 doesn't fill, a synthesized padding geom that has
+     ``mass = 0`` and ``density = 0``. Padding contributes nothing to
+     body inertia. Other variants' meshes are present in the merged
+     spec only as **mesh assets** (in the assets section, not as geoms
+     on any body). They get wired in at runtime via per-world
+     ``geom_dataid`` and never affect the host compile's inertial
+     sums.
+   * **Per-world overrides come from per-variant source compiles.**
+     Even with the above, the merged-scene compile's prop body inertia
+     is only correct for variant 0. For every other variant, mjlab
+     compiles that variant's original source spec in isolation (one
+     body, one variant's worth of meshes), reads the resulting
+     ``body_mass``, ``body_inertia``, ``body_ipos``, ``body_iquat``,
+     ``body_invweight0``, and ``body_subtreemass``, and writes them
+     into the per-world arrays at the prop body's index.
+
+   Net result: world W's prop body inertia is byte-equal to what you
+   would get by compiling variant W's source spec on its own. There
+   is a regression test
+   (``test_visual_collision_split_inertia_matches_independent_compile``
+   in ``tests/test_variants.py``) that asserts exactly this against
+   independent per-variant compiles.
+
+
+World assignment
+----------------
+
+How worlds get mapped to variants is controlled by the ``assignment``
+field on ``VariantEntityCfg``. It accepts three shapes:
+
+* ``None`` (default): uniform allocation across variants.
+* ``dict[str, float]``: per-variant weights. Variants not listed
+  default to weight 1.0.
+* ``Callable[[int], Sequence[int]]``: an explicit assignment function
+  called with ``num_envs`` at simulation init.
+
+Both the ``None`` and dict cases use the
+`largest remainder method
+<https://en.wikipedia.org/wiki/Largest_remainder_method>`_. Each
+variant's quota is ``q_i = (w_i / sum(w)) * num_envs``; each variant
+first receives ``floor(q_i)`` worlds, and the remaining
+``num_envs - sum(floors)`` worlds go to the variants with the largest
+fractional remainders, with ties broken by declaration order. For
+``num_envs = 10`` and weights ``(1.0, 2.0, 1.0)`` this gives
+``(3, 5, 2)`` worlds per variant. Weights are normalized internally,
+so ``{"a": 1, "b": 2, "c": 1}`` and ``{"a": 0.25, "b": 0.5, "c": 0.25}``
+produce identical assignments. A weight of zero is allowed and
+produces zero worlds for that variant; at least one variant must end
+up with positive weight.
+
+The default and dict paths are purely deterministic given
+``(assignment, num_envs)``. With ``assignment={"a": 1, "b": 1}`` and
+``num_envs = 8`` you always get ``[0, 0, 0, 0, 1, 1, 1, 1]``. There is
+no seed involved; rerunning the same config produces the same
+partition every time. Note that the partition's *boundaries* depend
+on ``num_envs``, so world W's variant is not necessarily stable when
+you change ``num_envs``. If you need explicit per-world stability
+across batch sizes (e.g. "world 0 is always variant 0, world 1 is
+always variant 1, regardless of how many envs I launch"), use a
+callable assignment as below.
+
+Variant assignment is fixed at ``Simulation`` initialization and does
+not resample on episode reset. The intended use is heterogeneous
+training across the batch, not per-episode mesh randomization.
+
+Read the resolved assignment from user code via
+``env.sim.world_to_variant``:
+
+.. code-block:: python
+
+    >>> env.sim.world_to_variant["object"]
+    tensor([0, 0, 0, 1, 1, 1, 1, 1, 1, 1])
+
+The mapping is keyed by entity name (without trailing slash) and
+returns a ``(num_envs,)`` tensor of variant indices in the order
+variants were declared in ``VariantEntityCfg.variants``. The dict is
+empty for non-variant scenes.
+
+
+Custom assignment with a callable
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+When the weighted default is not what you want, pass a callable to
+``assignment``. The callable receives ``num_envs`` and must return a
+length-``num_envs`` sequence of variant indices in
+``[0, len(variants))``. The returned sequence's length and bounds are
+validated at sim init; mismatches raise a ``ValueError`` naming the
+offending entity.
+
+A few patterns:
+
+**Round-robin** - cycle through variants by world index.
+
+.. code-block:: python
+
+    cfg = VariantEntityCfg(
+        variants={"a": make_a, "b": make_b, "c": make_c},
+        assignment=lambda n: [w % 3 for w in range(n)],
+    )
+
+**Stratified halves** - first half is variant 0, second half is
+variant 1.
+
+.. code-block:: python
+
+    cfg = VariantEntityCfg(
+        variants={"easy": make_easy, "hard": make_hard},
+        assignment=lambda n: [0] * (n // 2) + [1] * (n - n // 2),
+    )
+
+Domain randomization
+--------------------
+
+Domain randomization on variant scenes preserves per-variant baselines
+automatically. When the simulation initializes, mjlab snapshots the
+variant-dependent fields as ``(num_envs, ...)`` tensors and registers
+them in ``sim.per_world_default_fields``. DR operations that read
+defaults (scale, additive offsets) detect this registration and index
+the per-world default array by environment, so a 10% mass scale
+applied across a batch containing a 100 g sphere variant and a 1 kg
+cube variant produces 10% perturbations *around each variant's own
+mass*, not 10% of a shared template mass.
+
+Fields that are not variant-dependent (``geom_friction``,
+``dof_armature``, ``dof_damping``, and so on) behave identically on
+variant and non-variant scenes.
+
+For inertial randomization the recommended path is
+``dr.pseudo_inertia``, which jointly randomizes mass, COM offset,
+principal moments of inertia, and principal frame orientation through
+the pseudo-inertia matrix factorization of `Rucker and Wensing (2022)
+<https://par.nsf.gov/servlets/purl/10347458>`_. It is exact for any
+perturbation magnitude and remains physically consistent across
+variants of different scale. ``dr.body_mass`` modifies ``body_mass``
+without touching the inertia tensor and emits a ``UserWarning`` when
+called; it is appropriate only for modeling a point mass added at the
+COM, not for density-like randomization. The distinction matters more
+on variant scenes than on single-asset scenes because variants often
+differ in mass by an order of magnitude.
+
+
+Viewers
+-------
+
+The native viewer, offscreen renderer, and Viser viewer all sync the
+selected environment's per-world fields into the host ``MjModel``
+before rendering, so the rendered geometry matches the variant
+assigned to the viewed environment. Switching environments in the
+native viewer (the ``,`` and ``.`` keys) updates the displayed mesh
+accordingly.
+
+Viser bakes mesh data into batched handles and cannot rely on a live
+view of ``geom_dataid``. It groups worlds by visual fingerprint (mesh
+selection, local geom frames, baked appearance) and builds one batched
+handle per group, with each environment assigned to its handle. A
+scene with N variants typically produces up to N handles per body.
+Convex hull visualization is computed per variant from the variant's
+mesh vertices.
+
+
+Performance
+-----------
+
+**Per-step cost is unaffected by variant count.** Variant-dependent
+fields are stored as per-world arrays accessed by world index in the
+existing kernels, with no branching or dispatch on variant.
+
+**Construction cost is linear in the total variant count.** mjlab
+compiles the merged scene once to produce the canonical ``MjModel``,
+then compiles each variant's original (un-merged) source spec in
+isolation to recover that variant's per-body and per-geom mesh-derived
+fields. Each per-variant compile sees only that variant's single body
+and mesh, so its cost is independent of the total number of variants
+in the scene.
+
+For a scene with one variant entity declaring k variants, construction
+runs ``1 + k`` compiles. With multiple variant entities, compiles
+decouple across entities: two variant entities of 5 variants each cost
+``1 + 5 + 5 = 11`` compiles, not ``1 + 5 * 5 = 26``. As an order of
+magnitude on CPU with typical procedural meshes, each per-variant
+compile takes around 1-2 ms, so a scene with 100 variants pays a few
+hundred milliseconds at startup and a scene with 1000 variants pays
+roughly two seconds.
+
+The merged spec contains every variant's mesh assets simultaneously,
+so memory at scene-build time scales with the total mesh vertex /
+face count across all variants. This is paid once at startup and does
+not affect training throughput.
+
+
+Limitations
+-----------
+
+**Floating-base only.** Each variant's root body must declare a free
+joint. Fixed-base variants are rejected; mocap auto-wrapping that
+applies to non-variant entities is not applied here.
+
+**Material assets are not propagated.** Each variant's ``contype``,
+``conaffinity``, ``condim``, ``friction``, ``mass``, ``density``,
+``group``, ``priority``, ``rgba``, ``solref``, ``solimp``, ``margin``,
+and ``gap`` are restored per-world during compile, but the
+``material`` reference on slot geoms inherits whichever material the
+template variant set. Use DR on ``geom_rgba`` / ``mat_rgba`` for
+per-world appearance variation.
+
+**Assignment is fixed at sim init.** There is no API to swap a world
+to a different variant on episode reset. World W's mesh asset is
+whatever it was assigned at init for the lifetime of the simulation.
+Per-episode mesh randomization is not supported today; DR can vary
+scalar properties (mass, friction, color, scale) on a fixed variant
+but cannot swap one mesh for another.
+
+**No support for per-world differing kinematic topology.** Variants
+must share the same body tree, joints, and actuator/sensor counts,
+so you cannot configure things like:
+
+* a different number of objects per world (world 0 has two props on
+  the table, world 1 has three);
+* different articulation per world (world 0's prop is an articulated
+  drawer with a slider joint, world 1's prop is a rigid block).
+
+True heterogeneous topology requires upstream support in mujoco_warp
+that does not currently exist.
diff --git a/docs/source/environment_config.rst b/docs/source/environment_config.rst
new file mode 100644
index 0000000..2e21a95
--- /dev/null
+++ b/docs/source/environment_config.rst
@@ -0,0 +1,484 @@
+.. _environment_config:
+
+Environment Configuration
+=========================
+
+A single ``ManagerBasedRlEnvCfg`` dataclass fully specifies an mjlab
+environment: the physical world, the agent's interface to it, and the
+MDP defined on top. Because everything lives in one flat
+object, an environment can be inspected, copied, and modified without
+navigating a class hierarchy.
+
+For a broad orientation to mjlab before reading this page, start with
+:ref:`architecture_overview`.
+
+
+.. _env-config-skeleton:
+
+Annotated skeleton
+------------------
+
+The complete set of fields on ``ManagerBasedRlEnvCfg`` is shown below with
+inline comments. The fields marked with ``...`` must be provided; all others
+have defaults.
+
+.. code-block:: python
+
+    from dataclasses import dataclass, field
+
+    from mjlab.envs import ManagerBasedRlEnvCfg
+    from mjlab.managers.action_manager import ActionTermCfg
+    from mjlab.managers.command_manager import CommandTermCfg
+    from mjlab.managers.curriculum_manager import CurriculumTermCfg
+    from mjlab.managers.event_manager import EventTermCfg
+    from mjlab.managers.metrics_manager import MetricsTermCfg
+    from mjlab.managers.observation_manager import ObservationGroupCfg
+    from mjlab.managers.reward_manager import RewardTermCfg
+    from mjlab.managers.termination_manager import TerminationTermCfg
+    from mjlab.scene.scene import SceneCfg
+    from mjlab.sim.sim import SimulationCfg
+    from mjlab.viewer.viewer_config import ViewerConfig
+
+
+    @dataclass
+    class MyEnvCfg(ManagerBasedRlEnvCfg):
+
+        # --- Physics ---
+
+        decimation: int = 4
+        # Number of physics steps per policy step.
+        # Environment step duration = sim.mujoco.timestep * decimation.
+
+        sim: SimulationCfg = field(default_factory=SimulationCfg)
+        # Physics parameters: timestep, integrator, solver, contact settings.
+        # Default timestep is 0.002 s (500 Hz). Override with MujocoCfg.
+
+        scene: SceneCfg = ...
+        # Terrain, entities, and sensors. Also sets num_envs.
+        # Required; there is no default.
+
+        # --- Episode ---
+
+        episode_length_s: float = 20.0
+        # Episode duration in seconds.
+        # Steps = ceil(episode_length_s / (sim.mujoco.timestep * decimation)).
+
+        is_finite_horizon: bool = False
+        # False (default): time limit is an artificial cutoff. The agent
+        #   receives a truncated signal and bootstraps value beyond the limit.
+        # True: time limit defines the task boundary. The agent receives a
+        #   terminal done signal with no future value beyond it.
+
+        scale_rewards_by_dt: bool = True
+        # When True (default), each reward term is multiplied by step_dt so
+        # that cumulative episodic sums are invariant to simulation frequency.
+        # Set to False for algorithms that expect unscaled reward signals.
+
+        # --- Managers ---
+
+        observations: dict[str, ObservationGroupCfg] = field(default_factory=dict)
+        # Observation groups. Each key is a group name (e.g. "actor", "critic").
+        # Groups can differ in noise, history, delay, and concatenation.
+
+        actions: dict[str, ActionTermCfg] = field(default_factory=dict)
+        # Action terms. Each term controls one slice of the policy output
+        # and routes it to a specific entity's actuators.
+
+        rewards: dict[str, RewardTermCfg] = field(default_factory=dict)
+        # Reward terms. The manager computes a weighted sum each step.
+
+        terminations: dict[str, TerminationTermCfg] = field(default_factory=dict)
+        # Termination conditions. If empty, episodes never terminate early.
+        # Add a time_out term to enforce the episode length limit.
+
+        events: dict[str, EventTermCfg] = field(
+            default_factory=lambda: {
+                "reset_scene_to_default": EventTermCfg(
+                    func=reset_scene_to_default,
+                    mode="reset",
+                )
+            }
+        )
+        # Event terms for domain randomization and state resets.
+        # The default includes reset_scene_to_default, which resets all
+        # entities to their initial pose each episode. Override this dict
+        # to replace or extend the default reset behavior.
+
+        commands: dict[str, CommandTermCfg] = field(default_factory=dict)
+        # Command generators (e.g. velocity targets for locomotion).
+        # Commands are resampled at configurable intervals and on reset.
+
+        curriculum: dict[str, CurriculumTermCfg] = field(default_factory=dict)
+        # Curriculum terms that adjust training conditions based on performance.
+
+        metrics: dict[str, MetricsTermCfg] = field(default_factory=dict)
+        # Custom metrics logged as episode averages alongside reward terms.
+
+        # --- Misc ---
+
+        seed: int | None = None
+        # Random seed for reproducibility. If None, a random seed is chosen
+        # and stored back into this field after initialization.
+
+        viewer: ViewerConfig = field(default_factory=ViewerConfig)
+        # Camera position, resolution, and tracking target for rendering.
+
+
+.. _env-config-term-pattern:
+
+Term configuration pattern
+--------------------------
+
+All manager dictionaries follow the same pattern. Each entry maps a string
+name to a term configuration object. The configuration always carries at
+minimum a ``func`` field pointing to the callable that implements the term,
+and a ``params`` dict of extra keyword arguments forwarded to that callable.
+
+The manager calls ``func(env, **params)`` each step (or ``term(env, **params)``
+when ``func`` is a class that has been instantiated). Term names are arbitrary;
+they appear in training logs and are used only for identification.
+
+.. rubric:: Reward terms
+
+.. code-block:: python
+
+    from mjlab.envs import mdp
+    from mjlab.managers.reward_manager import RewardTermCfg
+    from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+    rewards = {
+        "alive": RewardTermCfg(
+            func=mdp.is_alive,
+            weight=1.0,
+        ),
+        "joint_torques": RewardTermCfg(
+            func=mdp.joint_torques_l2,
+            weight=-1e-4,
+            params={"asset_cfg": SceneEntityCfg("robot")},
+        ),
+        "action_rate": RewardTermCfg(
+            func=mdp.action_rate_l2,
+            weight=-0.1,
+        ),
+    }
+
+``weight`` scales the function's output before it is summed into the total
+reward. Negative weights produce penalties.
+
+``params`` maps to keyword arguments of the function. For example,
+``mdp.joint_torques_l2(env, asset_cfg=...)`` receives ``asset_cfg`` from the
+``params`` dict. Any argument not listed in ``params`` must have a default
+value in the function signature.
+
+.. rubric:: Termination terms
+
+.. code-block:: python
+
+    from mjlab.envs import mdp
+    from mjlab.managers.termination_manager import TerminationTermCfg
+
+    terminations = {
+        "time_out": TerminationTermCfg(
+            func=mdp.time_out,
+            time_out=True,   # marks this as a truncation, not a failure
+        ),
+        "fell_over": TerminationTermCfg(
+            func=mdp.bad_orientation,
+            params={"limit_angle": 1.22},   # ~70 degrees in radians
+        ),
+    }
+
+The ``time_out`` flag on ``TerminationTermCfg`` tells the manager to treat
+this condition as a truncation rather than a terminal failure. Truncations
+map to the ``truncated`` signal in the Gym interface; failures map to
+``terminated``. This distinction matters for value bootstrapping in RL
+algorithms.
+
+.. rubric:: Event terms
+
+.. code-block:: python
+
+    from mjlab.managers.event_manager import EventTermCfg
+
+    events = {
+        "reset_base": EventTermCfg(
+            func=mdp.reset_root_state_uniform,
+            mode="reset",
+            params={
+                "pose_range": {"yaw": (-3.14, 3.14)},
+                "velocity_range": {},
+            },
+        ),
+    }
+
+The ``mode`` field on ``EventTermCfg`` controls when the term fires:
+at startup, on episode reset, or at regular intervals. See :ref:`events`
+for the full treatment of lifecycle modes, built-in event functions, and
+the relationship between events and domain randomization.
+
+.. rubric:: Function-based vs. class-based terms
+
+Terms can be plain functions or classes. Functions are suitable for stateless
+computations; classes are useful when a term needs to cache expensive setup or
+maintain state across steps.
+
+A function-based term has the signature ``func(env, **params) -> Tensor``. A
+class-based term is instantiated once with ``(cfg, env)`` and then called with
+the same signature. Classes can optionally implement a ``reset(env_ids)`` hook
+for per-episode state clearing.
+
+.. code-block:: python
+
+    # Function-based (stateless)
+    RewardTermCfg(func=mdp.joint_torques_l2, weight=-0.01)
+
+    # Class-based (caches joint indices at init)
+    class MyReward:
+        def __init__(self, cfg, env):
+            self.joint_ids = resolve_joint_ids(cfg.params, env)
+
+        def __call__(self, env) -> torch.Tensor:
+            return compute_reward(env, self.joint_ids)
+
+    RewardTermCfg(func=MyReward, weight=1.0)
+
+
+.. _env-config-timing:
+
+Timing: decimation, timestep, and episode length
+-------------------------------------------------
+
+Three parameters jointly determine the temporal structure of the environment.
+
+``sim.mujoco.timestep``
+    The physics integration step in seconds. The default is 0.002 s (500 Hz).
+    This is one of the most important parameters in any environment: smaller
+    values produce more stable physics but slow down simulation. See the MuJoCo
+    `performance tuning <https://mujoco.readthedocs.io/en/stable/modeling.html#performance-tuning>`_
+    guide for practical advice on choosing timesteps and solver settings.
+
+``decimation``
+    The number of physics steps executed per policy step. The policy runs at
+    ``1 / (timestep * decimation)`` Hz.
+
+``episode_length_s``
+    The episode duration in seconds. The maximum number of policy steps per
+    episode is ``ceil(episode_length_s / (timestep * decimation))``.
+
+**Concrete example.** The velocity task uses ``timestep=0.005`` (200 Hz
+physics) and ``decimation=4``, giving a policy frequency of 50 Hz. With
+``episode_length_s=20.0``, each episode runs for exactly 1000 policy steps.
+
+.. code-block:: python
+
+    physics_dt  = 0.005        # seconds per physics step (200 Hz)
+    decimation  = 4            # physics steps per policy step
+    step_dt     = 0.005 * 4   # = 0.02 s per policy step (50 Hz)
+    episode_len = 20.0 / 0.02  # = 1000 policy steps per episode
+
+To read these values at runtime, use the environment properties:
+
+.. code-block:: python
+
+    env.physics_dt          # = cfg.sim.mujoco.timestep
+    env.step_dt             # = cfg.sim.mujoco.timestep * cfg.decimation
+    env.max_episode_length  # steps (int)
+    env.max_episode_length_s  # seconds (float)
+
+When ``scale_rewards_by_dt=True`` (the default), each reward term is
+multiplied by ``step_dt`` before being returned. A reward function that
+returns a constant value of 1.0 contributes ``step_dt`` per step and
+approximately ``episode_length_s`` over a full episode, regardless of how
+``decimation`` and ``timestep`` are set. Changing the simulation frequency
+without disabling this scaling leaves reward magnitudes unchanged.
+
+
+.. _env-config-subclassing:
+
+Subclassing pattern
+-------------------
+
+mjlab uses plain dataclass inheritance rather than deeply nested class
+hierarchies. To build a task-specific configuration, subclass
+``ManagerBasedRlEnvCfg`` and override fields.
+
+The recommended approach is to define the full configuration in a factory
+function, then call it from robot-specific configs that override only the
+fields that differ. The velocity task uses this pattern: ``make_velocity_env_cfg``
+returns a fully assembled ``ManagerBasedRlEnvCfg``, and each robot
+configuration calls the factory and patches in robot-specific values such
+as the scene, joint name patterns, and action scale.
+
+A condensed version of the factory illustrates the full assembly pattern:
+
+.. code-block:: python
+
+    import math
+    from dataclasses import replace
+
+    from mjlab.envs import ManagerBasedRlEnvCfg
+    from mjlab.envs.mdp import dr
+    from mjlab.envs.mdp.actions import JointPositionActionCfg
+    from mjlab.managers.event_manager import EventTermCfg
+    from mjlab.managers.observation_manager import ObservationGroupCfg, ObservationTermCfg
+    from mjlab.managers.reward_manager import RewardTermCfg
+    from mjlab.managers.scene_entity_config import SceneEntityCfg
+    from mjlab.managers.termination_manager import TerminationTermCfg
+    from mjlab.scene import SceneCfg
+    from mjlab.sim import MujocoCfg, SimulationCfg
+    from mjlab.tasks.velocity import mdp
+    from mjlab.tasks.velocity.mdp import UniformVelocityCommandCfg
+    from mjlab.terrains import TerrainEntityCfg
+    from mjlab.terrains.config import ROUGH_TERRAINS_CFG
+    from mjlab.viewer import ViewerConfig
+
+
+    def make_velocity_env_cfg() -> ManagerBasedRlEnvCfg:
+
+        observations = {
+            "actor": ObservationGroupCfg(
+                terms={
+                    "base_lin_vel": ObservationTermCfg(
+                        func=mdp.builtin_sensor,
+                        params={"sensor_name": "robot/imu_lin_vel"},
+                    ),
+                    "joint_pos": ObservationTermCfg(func=mdp.joint_pos_rel),
+                    "command": ObservationTermCfg(
+                        func=mdp.generated_commands,
+                        params={"command_name": "twist"},
+                    ),
+                    # additional terms omitted for brevity
+                },
+                concatenate_terms=True,
+                enable_corruption=True,
+            ),
+            "critic": ObservationGroupCfg(
+                terms={...},
+                concatenate_terms=True,
+                enable_corruption=False,
+            ),
+        }
+
+        actions = {
+            "joint_pos": JointPositionActionCfg(
+                entity_name="robot",
+                actuator_names=(".*",),
+                scale=0.5,
+                use_default_offset=True,
+            )
+        }
+
+        commands = {
+            "twist": UniformVelocityCommandCfg(
+                entity_name="robot",
+                resampling_time_range=(3.0, 8.0),
+                ranges=UniformVelocityCommandCfg.Ranges(
+                    lin_vel_x=(-1.0, 1.0),
+                    lin_vel_y=(-1.0, 1.0),
+                    ang_vel_z=(-0.5, 0.5),
+                    heading=(-math.pi, math.pi),
+                ),
+            )
+        }
+
+        events = {
+            "reset_base": EventTermCfg(
+                func=mdp.reset_root_state_uniform,
+                mode="reset",
+                params={
+                    "pose_range": {"x": (-0.5, 0.5), "y": (-0.5, 0.5), "yaw": (-3.14, 3.14)},
+                    "velocity_range": {},
+                },
+            ),
+            "foot_friction": EventTermCfg(
+                mode="startup",
+                func=dr.geom_friction,
+                params={
+                    "asset_cfg": SceneEntityCfg("robot", geom_names=[]),
+                    "operation": "abs",
+                    "ranges": (0.3, 1.2),
+                },
+            ),
+            "push_robot": EventTermCfg(
+                func=mdp.push_by_setting_velocity,
+                mode="interval",
+                interval_range_s=(1.0, 3.0),
+                params={"velocity_range": {"x": (-0.5, 0.5), "y": (-0.5, 0.5)}},
+            ),
+        }
+
+        rewards = {
+            "track_linear_velocity": RewardTermCfg(
+                func=mdp.track_linear_velocity,
+                weight=2.0,
+                params={"command_name": "twist", "std": math.sqrt(0.25)},
+            ),
+            "dof_pos_limits": RewardTermCfg(func=mdp.joint_pos_limits, weight=-1.0),
+            "action_rate_l2": RewardTermCfg(func=mdp.action_rate_l2, weight=-0.1),
+        }
+
+        terminations = {
+            "time_out": TerminationTermCfg(func=mdp.time_out, time_out=True),
+            "fell_over": TerminationTermCfg(
+                func=mdp.bad_orientation,
+                params={"limit_angle": math.radians(70.0)},
+            ),
+        }
+
+        return ManagerBasedRlEnvCfg(
+            decimation=4,
+            episode_length_s=20.0,
+            sim=SimulationCfg(
+                nconmax=35,
+                njmax=1500,
+                mujoco=MujocoCfg(timestep=0.005, iterations=10, ls_iterations=20),
+            ),
+            scene=SceneCfg(
+                terrain=TerrainEntityCfg(
+                    terrain_type="generator",
+                    terrain_generator=replace(ROUGH_TERRAINS_CFG),
+                    max_init_terrain_level=5,
+                ),
+                num_envs=1,
+            ),
+            observations=observations,
+            actions=actions,
+            commands=commands,
+            events=events,
+            rewards=rewards,
+            terminations=terminations,
+        )
+
+Robot-specific configs call this factory and patch fields using
+``dataclasses.replace`` or direct assignment. Common per-robot overrides
+include ``scene`` (to add the robot entity and sensors), joint name patterns
+inside ``SceneEntityCfg``, action ``scale``, and body names for reward terms.
+
+.. note::
+
+   Isaac Lab uses deeply nested ``__post_init__`` overrides for configuration
+   inheritance. mjlab avoids that pattern: each ``ManagerBasedRlEnvCfg`` is a
+   flat, inspectable dataclass. A misspelled field name raises a ``TypeError``
+   at construction rather than silently creating a new attribute. See
+   :ref:`migration_isaac_lab` for a full comparison.
+
+
+Where to go next
+----------------
+
+The remaining pages in the Manager Layer section cover each manager in
+detail:
+
+- :ref:`observations`: observation groups, the processing pipeline
+  (clip, scale, noise, delay, history), and built-in observation functions.
+- :ref:`actions`: action types and how the action manager routes policy
+  output to actuators.
+- :ref:`rewards`: reward terms and scaling by dt.
+- :ref:`terminations`: episode end conditions and the truncation/failure
+  distinction.
+- :ref:`commands`: command generators and goal-conditioned task setup.
+- :ref:`events`: the event manager lifecycle (startup, reset, interval).
+- :ref:`domain_randomization`: the full ``dr`` module for domain
+  randomization.
+- :ref:`curriculum`: difficulty progression based on policy performance.
+- :ref:`metrics`: custom per-step metrics logged as episode averages.
diff --git a/docs/source/events.rst b/docs/source/events.rst
new file mode 100644
index 0000000..7d4e38e
--- /dev/null
+++ b/docs/source/events.rst
@@ -0,0 +1,212 @@
+.. _events:
+
+Events
+======
+
+The event manager executes hooks at specific points in the environment
+lifecycle. Any logic that should run at startup, on episode reset, or at
+regular intervals during training is registered as an event term. Common
+examples include resetting entities to an initial state, applying domain
+randomization to model parameters, pushing the robot with random velocity
+perturbations, and initializing robot state from a reference motion clip.
+All of these are configured through the same ``EventTermCfg`` interface,
+differing only in the ``mode`` field that controls when each term fires.
+
+Domain randomization, one of the most common uses of events, has its own
+dedicated reference page. See :ref:`domain_randomization` for the full
+``dr`` module, available functions, and internals.
+
+.. code-block:: python
+
+    from mjlab.envs.mdp import events as event_fns, dr
+    from mjlab.managers.event_manager import EventTermCfg
+    from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+    events = {
+        # Reset all entities to their default state each episode.
+        "reset_scene": EventTermCfg(
+            func=event_fns.reset_scene_to_default,
+            mode="reset",
+        ),
+        # Randomize foot friction once at startup.
+        "foot_friction": EventTermCfg(
+            func=dr.geom_friction,
+            mode="startup",
+            params={
+                "asset_cfg": SceneEntityCfg("robot", geom_names=[".*foot.*"]),
+                "ranges": (0.3, 1.2),
+                "operation": "abs",
+            },
+        ),
+        # Push the robot at random intervals during the episode.
+        "push_robot": EventTermCfg(
+            func=event_fns.push_by_setting_velocity,
+            mode="interval",
+            interval_range_s=(1.0, 3.0),
+            params={
+                "velocity_range": {"x": (-0.5, 0.5), "y": (-0.5, 0.5)},
+            },
+        ),
+        # Transient random impulses with duration and cooldown.
+        "impulse": EventTermCfg(
+            func=event_fns.apply_body_impulse,
+            mode="step",
+            params={
+                "force_range": (-50.0, 50.0),
+                "torque_range": (0.0, 0.0),
+                "duration_s": (0.1, 0.2),
+                "cooldown_s": (1.0, 3.0),
+                "asset_cfg": SceneEntityCfg("robot", body_names=("base",)),
+            },
+        ),
+    }
+
+
+Lifecycle modes
+---------------
+
+The ``mode`` field on ``EventTermCfg`` determines when the term fires. The
+four modes correspond to the timescales of an RL training run: once at
+process startup, once per episode, periodically within an episode, and on
+every environment step.
+
+``"startup"``
+    Fires once during environment initialization, after all managers are
+    constructed. Every environment receives the event simultaneously. This
+    mode is intended for parameters that should differ across environments
+    but remain fixed for the entire training run, such as link masses or
+    joint armatures randomized via the ``dr`` module.
+
+``"reset"``
+    Fires on every episode reset, for each environment being reset. This is
+    the most common mode. State initialization (writing the robot back to
+    its default pose) and episode-level domain randomization both belong
+    here.
+
+    The optional ``min_step_count_between_reset`` field prevents the term
+    from firing too frequently when episodes are very short. The term is
+    skipped for any environment that has not taken at least that many steps
+    since its last trigger. The first invocation always fires regardless.
+
+``"interval"``
+    Fires at regular time intervals during training, independent of episode
+    boundaries. The trigger frequency is controlled by ``interval_range_s``,
+    a ``(min, max)`` range in seconds. After each trigger the manager
+    samples a new wait time uniformly from that range. Each environment has
+    its own independent timer by default; setting ``is_global_time=True``
+    synchronizes all environments to a single shared timer. Interval events
+    are the natural home for mid-episode perturbations such as external
+    pushes or drifting model parameters.
+
+``"step"``
+    Fires on every environment step, for all environments. This mode is
+    intended for continuous effects that must be evaluated each step, such
+    as ``apply_body_impulse`` which manages its own internal duration and
+    cooldown timers. Because step events run every step, they should be
+    lightweight or manage their own activation logic internally to avoid
+    unnecessary computation.
+
+As with all manager terms, ``func`` points to the callable and ``params``
+holds keyword arguments forwarded to it alongside ``env`` and ``env_ids``.
+Any ``SceneEntityCfg`` values inside ``params`` are resolved once at
+manager construction (regex patterns are matched to model indices at that
+point, not on every call). Terms can be plain functions or classes; see
+:ref:`env-config-term-pattern` for the general pattern.
+
+
+Built-in event functions
+------------------------
+
+The functions below are available in ``mjlab.envs.mdp.events``.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 70
+
+   * - Function
+     - Description
+   * - ``reset_scene_to_default``
+     - Resets all entities to their default states: root pose and velocity
+       for floating-base entities, mocap pose for fixed-base entities, and
+       joint positions and velocities for articulated entities. Environment
+       origins are applied automatically. This is the default event on
+       ``ManagerBasedRlEnvCfg``; most environments keep it and add
+       additional terms alongside it.
+   * - ``reset_root_state_uniform``
+     - Resets a single entity's root pose and velocity with uniform random
+       offsets from the default. Accepts ``pose_range`` and
+       ``velocity_range`` dictionaries with keys ``"x"``, ``"y"``,
+       ``"z"``, ``"roll"``, ``"pitch"``, ``"yaw"``. Orientation
+       perturbations compose with the default quaternion. For fixed-base
+       robots, this is the only way to position them at their environment
+       origins; without it they stack at the world origin.
+   * - ``reset_root_state_from_flat_patches``
+     - Places an entity on a randomly chosen flat terrain patch based on
+       the environment's assigned terrain level and type. Falls back to
+       ``reset_root_state_uniform`` when no flat patches are available.
+       Useful for locomotion tasks where robots should spawn on level
+       ground within their assigned sub-terrain.
+   * - ``reset_joints_by_offset``
+     - Resets joint positions and velocities by adding a uniform random
+       offset to the entity's defaults, clamped to soft joint limits.
+   * - ``push_by_setting_velocity``
+     - Adds a random velocity increment to the entity's current root
+       velocity, simulating an external push. Typically used with
+       ``mode="interval"`` to test disturbance rejection.
+   * - ``apply_external_force_torque``
+     - Applies random forces and torques to one or more bodies via the
+       MuJoCo external wrench mechanism.
+   * - ``apply_body_impulse``
+     - Applies transient external wrenches to bodies with configurable
+       duration and cooldown. Each environment independently samples a
+       random force direction and holds it for a sampled duration, then
+       waits through a cooldown before firing again. Supports an optional
+       ``body_point_offset`` to shift the application point away from the
+       center of mass. Includes built in debug visualization that draws
+       force arrows in the viewer. Use with ``mode="step"``.
+   * - ``randomize_terrain``
+     - Assigns each environment to a random sub-terrain row and column,
+       ignoring the curriculum. Useful for evaluation or play mode.
+
+
+Writing custom event terms
+--------------------------
+
+An event function takes ``env`` and ``env_ids`` as its first two arguments
+and any additional parameters from ``EventTermCfg.params``. It modifies
+simulation state in place and returns nothing. For terms that need
+expensive one-time setup (such as loading data from disk), use a class
+so that the setup runs once at construction rather than on every call.
+For example, the following custom event term resets the robot to a
+random pose sampled from a pre-recorded dataset:
+
+.. code-block:: python
+
+    import torch
+    from mjlab.managers.manager_base import ManagerTermBase
+    from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+    class ResetFromDataset(ManagerTermBase):
+        """Reset the robot to a random pose from a dataset."""
+
+        def __init__(self, cfg, env):
+            super().__init__(env)
+            self._robot = env.scene["robot"]
+            self._poses = torch.load(
+                cfg.params["dataset_path"],
+                map_location=env.device,
+            )
+
+        def __call__(self, env, env_ids, **kwargs):
+            # Sample with replacement: each env gets an independent pose.
+            indices = torch.randint(
+                len(self._poses), (len(env_ids),), device=env.device,
+            )
+            self._robot.write_joint_position_to_sim(
+                self._poses[indices], env_ids=env_ids,
+            )
+
+When a term needs to maintain state or perform expensive setup, implement
+it as a class. See :ref:`env-config-term-pattern` for the general
+pattern. For custom DR terms that write to model fields, see
+:ref:`domain_randomization`.
diff --git a/docs/source/faq.rst b/docs/source/faq.rst
new file mode 100644
index 0000000..808bb09
--- /dev/null
+++ b/docs/source/faq.rst
@@ -0,0 +1,546 @@
+.. _faq:
+
+FAQ & Troubleshooting
+=====================
+
+This page collects common questions about **platform support**, **performance**,
+**training stability**, and **visualization**, along with practical debugging
+tips and links to further resources.
+
+Platform Support
+----------------
+
+Does it work on macOS?
+~~~~~~~~~~~~~~~~~~~~~~
+
+Yes, but only with limited performance. mjlab runs on macOS
+using **CPU-only** execution through MuJoCo Warp.
+
+- **Training is not recommended on macOS**, as it lacks GPU acceleration.
+- **Evaluation works**, but is significantly slower than on Linux with CUDA.
+
+For serious training workloads, we strongly recommend **Linux with an NVIDIA GPU**.
+
+Does it work on Windows?
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+We have performed preliminary testing on **Windows** and **WSL**, but some
+workflows are not guaranteed to be stable.
+
+- Windows support may **lag behind** Linux.
+- Windows will be **tested less frequently**, since Linux is the primary
+  development and deployment platform.
+- Community contributions that improve Windows support are very welcome.
+
+CUDA Compatibility
+~~~~~~~~~~~~~~~~~~
+
+Not all CUDA versions are supported by MuJoCo Warp.
+
+- See `mujoco_warp#101 <https://github.com/google-deepmind/mujoco_warp/issues/101>`_
+  for details on CUDA compatibility.
+- **Recommended**: CUDA **12.4+** (for conditional execution support in CUDA
+  graphs).
+
+How do I run on CPU without touching the GPU?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Passing ``device="cpu"`` puts all mjlab computation on the CPU, but it does
+**not** stop Warp from initializing the GPU. The first time Warp's runtime
+comes up, it eagerly enumerates and creates a CUDA context on **every**
+visible device, regardless of which device you requested. So on a machine
+with a visible GPU, a ``device="cpu"`` run still claims VRAM.
+
+This happens inside Warp and cannot be prevented from Python once the
+package is imported. To keep the process entirely off the GPU, hide the
+devices from CUDA before launching:
+
+.. code-block:: bash
+
+   CUDA_VISIBLE_DEVICES="" uv run train.py ...
+
+With no visible CUDA devices, Warp initializes CPU-only and never allocates
+on the GPU. See `issue #949
+<https://github.com/mujocolab/mjlab/issues/949>`_ for background.
+
+Performance
+-----------
+
+Is it faster than Isaac Lab?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Based on our experience over the last few months, mjlab is **on par or
+faster** than Isaac Lab.
+
+What GPU do you recommend?
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- **RTX 40-series GPUs** (or newer)
+- **L40s, H100**
+
+Does mjlab support multi-GPU training?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Yes, mjlab supports **multi-GPU distributed training** using
+`torchrunx <https://github.com/apoorvkh/torchrunx>`_.
+
+- Use ``--gpu-ids "[0, 1]"`` (or ``--gpu-ids all``) when running the ``train``
+  command.
+- See the :doc:`training/distributed_training` for configuration details and examples.
+
+Training & Debugging
+--------------------
+
+My training crashes with NaN errors
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A typical error when using ``rsl_rl`` looks like:
+
+.. code-block:: bash
+
+   RuntimeError: normal expects all elements of std >= 0.0
+
+This occurs when NaN/Inf values in the **physics state** propagate to the
+policy network, causing its output standard deviation to become negative or NaN.
+
+There are many possible causes, including potential bugs in **MuJoCo Warp**
+(which is still in beta). mjlab offers two complementary mechanisms to help
+you handle this:
+
+1. **For training stability** - NaN termination
+
+Add a ``nan_detection`` termination to reset environments that hit NaN:
+
+.. code-block:: python
+
+   from mjlab.envs.mdp import terminations as mdp_term
+   from mjlab.managers.termination_manager import TerminationTermCfg
+
+   # In your ManagerBasedRlEnvCfg subclass:
+   terminations = {
+      # Your other terminations...
+      "nan_term": TerminationTermCfg(func=mdp_term.nan_detection),
+   }
+
+This marks NaN environments as terminated so they can reset while training
+continues. Terminations are logged as
+``Episode_Termination/nan_term`` in your metrics.
+
+.. warning::
+
+   This is a **band-aid solution**. If NaNs correlate with your task objective
+   (for example, NaNs occur exactly when the agent tries to grasp an object),
+   the policy will never learn to complete that part of the task. Always
+   investigate the **root cause** using ``nan_guard`` in addition to this
+   termination.
+
+2. **For debugging** - NaN guard
+
+Enable ``nan_guard`` to capture the simulation state when NaNs occur:
+
+.. code-block:: bash
+
+   uv run train.py --enable-nan-guard True
+
+See the :doc:`NaN Guard documentation <debugging/nan_guard>` for details.
+
+The ``nan_guard`` tool makes it easier to:
+
+- Inspect the simulation state at the moment NaNs appear.
+- Build a minimal reproducible example (MRE).
+- Report potential framework bugs to the
+  `MuJoCo Warp team <https://github.com/google-deepmind/mujoco_warp/issues>`_.
+
+Reporting well-isolated issues helps improve the framework for everyone.
+
+How can I inspect the generated scene XML?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Use the ``export-scene`` script to write the full scene (XML and mesh assets)
+to a directory:
+
+.. code-block:: bash
+
+    uv run export-scene g1 --output-dir /tmp/g1
+
+The exported ``scene.xml`` can be loaded directly in MuJoCo for visual
+inspection or diffing. This is useful for verifying that task configuration
+and physics are set up correctly, and for creating minimal reproducible
+examples to share with mjlab or MuJoCo Warp developers. The script accepts task IDs,
+entity aliases (``g1``, ``go1``, ``yam``), or arbitrary import paths. See
+:doc:`debugging/export_scene` for full details.
+
+My contact sensor misses collisions when using decimation
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+With ``decimation > 1`` the physics runs multiple substeps per policy
+step. A brief contact (e.g. a self collision or an illegal ground touch)
+can appear and disappear within the substep loop, so by the time the
+sensor is read, ``found`` is zero and the event is invisible to
+rewards and terminations.
+
+Set ``history_length`` on the ``ContactSensorCfg`` equal to your
+decimation value. The sensor then stores force, torque, and distance
+for the last *N* substeps. Your reward or termination function can
+inspect the history to detect contacts that would otherwise be missed:
+
+.. code-block:: python
+
+    ContactSensorCfg(
+        name="self_collision",
+        ...,
+        fields=("found", "force"),
+        history_length=4,  # matches decimation=4
+    )
+
+    # In the reward/termination function:
+    force_mag = torch.norm(sensor.data.force_history, dim=-1)  # [B, N, H]
+    had_contact = (force_mag > 10.0).any(dim=1).any(dim=-1)    # [B]
+
+See :ref:`contact-sensor-history` for full details.
+
+.. note::
+
+   Feet ground sensors with ``track_air_time=True`` already accumulate
+   contact state across substeps, so they do not need history.
+
+.. _faq-sim-forward:
+
+When do I need to call ``sim.forward()``?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Short answer: you almost certainly don't.
+
+``sim.forward()`` wraps MuJoCo's ``mj_forward``, which runs the full forward
+dynamics pipeline (kinematics, contacts, forces, constraint solving, sensors)
+but skips integration, leaving ``qpos``/``qvel`` unchanged. It brings all
+derived quantities in ``mjData`` (``xpos``, ``xquat``, ``site_xpos``,
+``cvel``, ``sensordata``, etc.) into a consistent state with the current
+``qpos``/``qvel``.
+The environment's ``step()`` method calls it once per step, right before
+observation computation, so observations and commands always see fresh
+derived quantities. Termination, reward, and step/interval events run
+*before* this call and therefore see derived quantities that are stale by
+one physics substep, a deliberate tradeoff that avoids a second
+``forward()`` call while keeping the MDP well-defined (the staleness is
+consistent across all envs and all steps). Because events run before the
+call, any state they write (e.g. a velocity push) is refreshed by it and
+visible to the same step's observations.
+
+The one case where this matters is if you write an event or command that
+both writes state and reads derived quantities in the same function. For
+example, if Event A calls ``entity.write_root_velocity_to_sim()`` (which
+modifies ``qvel``) and then immediately reads ``entity.data.root_link_vel_w``
+(which comes from ``cvel``), the read will see stale values from before the
+write.
+
+.. warning::
+
+   Write methods (``write_root_state_to_sim``, ``write_joint_state_to_sim``,
+   etc.) modify ``qpos``/``qvel`` directly. Read properties
+   (``root_link_pose_w``, ``body_link_vel_w``, etc.) return derived
+   quantities that are only current as of the last ``sim.forward()`` call.
+   If you need to write then read in the same function, call
+   ``env.sim.forward()`` between them.
+
+For a deeper explanation, see `Discussion #289
+<https://github.com/mujocolab/mjlab/discussions/289>`_.
+
+Why aren't my training runs reproducible even with a fixed seed?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+MuJoCo Warp does not yet guarantee determinism, so running the same
+simulation with identical inputs may produce slightly different outputs.
+This is a known limitation being tracked in
+`mujoco_warp#562 <https://github.com/google-deepmind/mujoco_warp/issues/562>`_.
+
+Until determinism is implemented upstream, mjlab training runs will not be
+perfectly reproducible even when setting a seed.
+
+My XML ``<option>`` flags are not taking effect
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If you set simulation options like ``<flag contact="disable"/>`` in your
+entity XML, they will be silently ignored. This is because mjlab composes
+scenes by attaching entity specs into a parent scene spec using
+``MjSpec.attach()``, which does not propagate ``<option>`` settings from
+the child to the parent. This is a MuJoCo design decision: there is no
+sensible way to merge engine options (timestep, gravity, solver settings,
+etc.) across multiple attached models.
+
+To configure simulation options, use :class:`~mjlab.sim.sim.MujocoCfg` in
+your task's Python config:
+
+.. code-block:: python
+
+   from mjlab.sim.sim import MujocoCfg, SimulationCfg
+
+   sim=SimulationCfg(
+       mujoco=MujocoCfg(
+           disableflags=("contact",),
+           # timestep=0.01, gravity=(0, 0, -9.81), etc.
+       ),
+   )
+
+``MujocoCfg`` applies options directly to the compiled model, so they
+always take effect. mjlab will emit a warning if it detects non-default
+``<option>`` fields on an attached entity spec.
+
+Rendering & Visualization
+-------------------------
+
+What visualization options are available?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+mjlab currently supports two visualizers for policy evaluation and
+debugging:
+
+- **Native MuJoCo visualizer** - the built-in visualizer that ships with MuJoCo.
+- **Viser** - `Viser <https://github.com/nerfstudio-project/viser>`_,
+  a web-based 3D visualization tool.
+
+We are exploring **training-time visualization** (e.g., live rollout viewers),
+but this is not yet available.
+
+As an alternative, mjlab supports **video logging to Weights & Biases
+(W&B)**, so you can monitor rollout videos directly in the experiment dashboard.
+
+How many environments can I visualize at once?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Viewers render a small number of environments for performance reasons.
+
+- **Offscreen renderer** (for video recording): Renders the tracked
+  environment plus its nearest neighbors. The count is controlled by
+  ``ViewerConfig.max_extra_envs`` (default 2).
+- **Native/Viser viewers**: Limited by MuJoCo's geometry buffer
+  (default 10,000 geoms). The viewer shows whichever environments fit
+  within the geometry budget.
+
+Why are my fixed-base robots all stacked at the origin instead of in a grid?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Fixed-base robots require an **explicit reset event** to position them at
+their ``env_origins``. If your robots appear stacked at (0, 0, 0):
+
+**Common causes:**
+
+1. **Missing reset event** - Most common issue.
+2. **env_spacing is 0 or very small** - Check your ``SceneCfg(env_spacing=...)``.
+   Even with proper reset events, if ``env_spacing=0.0``, all robots will
+   be at the same position. If ``env_spacing`` is very small (e.g., 0.01),
+   they'll be clustered in a tiny area that looks like a line from a distance.
+
+**Solution**: Add a reset event that calls ``reset_root_state_uniform``:
+
+.. code-block:: python
+
+   # In your ManagerBasedRlEnvCfg
+   events = {
+     # For positioning the base of the robot at env_origins.
+     "reset_base": EventTermCfg(
+       func=mdp.reset_root_state_uniform,
+       mode="reset",
+       params={
+         "pose_range": {},  # Empty = use default pose + env_origins
+         "velocity_range": {},
+       },
+     ),
+     # ... other events
+   }
+
+This pattern is used in the example manipulation task (see ``lift_cube_env_cfg.py:85-94``).
+
+**Why this is needed**: Fixed-base robots are automatically wrapped in mocap
+bodies by ``auto_wrap_fixed_base_mocap()``, but mocap positioning only happens
+when you explicitly call a reset event. The ``env_origins`` offset is applied
+inside ``reset_root_state_uniform()`` at line 131 of ``envs/mdp/events.py``.
+
+See `issue #560 <https://github.com/mujocolab/mjlab/issues/560>`_ for examples.
+
+How does env_origins determine robot layout?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Robot spacing depends on your terrain configuration:
+
+**Plane terrain** (``terrain_type="plane"``):
+  - Creates an approximately square grid automatically
+  - Grid size: ``ceil(sqrt(num_envs))`` rows x cols
+  - Spacing controlled by ``env_spacing`` parameter (default: 2.0m)
+  - Examples with ``env_spacing=2.0``:
+    - 32 envs → 7x5 grid spanning 12m x 8m
+    - 4096 envs → 64x64 grid spanning 126m x 126m
+  - **Important**: If ``env_spacing=0``, all robots will be at (0, 0, 0)
+  - Implementation: ``terrain_importer.py:_compute_env_origins_grid()``
+
+**Procedural terrain** (``terrain_type="generator"``):
+  - Origins loaded from pre-generated terrain sub-patches
+  - Grid size: ``TerrainGeneratorCfg.num_rows x num_cols``
+  - Row index = difficulty level (curriculum mode)
+  - Column index = terrain type variant
+  - **Important allocation behavior**: Columns (terrain types) are evenly distributed
+    across environments, but rows (difficulty levels) are randomly sampled. This means
+    multiple environments can spawn on the same (row, col) patch, leaving others unoccupied,
+    even when ``num_envs > num_patches``.
+  - Example: 5x5 grid (25 patches), 100 envs → each column gets exactly 20 envs,
+    but those 20 are randomly distributed across 5 rows, so some patches remain empty.
+  - Supports ``randomize_env_origins()`` to shuffle positions during training
+
+How do I ensure each terrain type gets its own column?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Set ``curriculum=True`` in your ``TerrainGeneratorCfg``. This makes column
+allocation deterministic, with each column getting one terrain type based on
+normalized proportions.
+
+Example with 2 terrain types:
+
+.. code-block:: python
+
+   TerrainGeneratorCfg(
+     num_rows=3,
+     num_cols=2,
+     curriculum=True,  # Required for deterministic column allocation!
+     sub_terrains={
+       "flat": BoxFlatTerrainCfg(proportion=0.5),  # Gets column 0
+       "pillars": HfDiscreteObstaclesTerrainCfg(
+         proportion=0.5,  # Gets column 1
+       ),
+     },
+   )
+
+Without ``curriculum=True``, every patch is randomly sampled and you'll get
+a random mix of both terrain types scattered across all patches.
+
+**Note**: When ``num_cols`` equals the number of terrain types, each terrain
+gets exactly one column regardless of proportion values (they're normalized).
+When ``num_cols > num_terrain_types``, proportions determine how many columns
+each terrain type occupies.
+
+What is flat patch sampling and how does it affect robot spawning?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Flat patch sampling detects flat regions on heightfield terrains where robots
+can safely spawn. It uses morphological filtering on the heightfield to find
+circular areas where height variation is within a tolerance.
+
+Configure it on any sub-terrain via ``flat_patch_sampling``:
+
+.. code-block:: python
+
+   from mjlab.terrains.terrain_generator import FlatPatchSamplingCfg
+
+   "obstacles": HfDiscreteObstaclesTerrainCfg(
+     ...,
+     flat_patch_sampling={
+       "spawn": FlatPatchSamplingCfg(
+         num_patches=10,      # patches to sample per sub-terrain
+         patch_radius=0.5,    # flatness check radius (meters)
+         max_height_diff=0.05,  # max height variation within radius
+       ),
+     },
+   )
+
+Then use ``reset_root_state_from_flat_patches`` as your reset event to spawn
+robots on detected patches instead of at the sub-terrain center.
+
+**Key details:**
+
+- Only heightfield (``Hf*``) terrains support actual flat patch detection.
+  Box terrains (``Box*``) don't have heightfield data to analyze.
+- If any sub-terrain in the grid configures ``flat_patch_sampling``, the
+  flat patches array is allocated for **all** cells. Sub-terrains that don't
+  produce patches have their slots filled with the sub-terrain's spawn origin,
+  so ``reset_root_state_from_flat_patches`` always gets valid positions.
+- Without ``flat_patch_sampling``, use ``reset_root_state_uniform`` which
+  spawns at the sub-terrain origin (``env_origins``) plus an optional random
+  offset.
+
+Development & Extensions
+------------------------
+
+Can I develop custom tasks in my own repository?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Yes, mjlab has a **plugin system** that lets you develop tasks in separate
+repositories while still integrating seamlessly with the core:
+
+- Your tasks appear as regular entries for the ``train`` and ``play`` commands.
+- You can version and maintain your task repositories independently.
+
+A complete guide will be available in a future release.
+
+Assets & Compatibility
+----------------------
+
+What robots are included?
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+mjlab includes two **reference robots**:
+
+- **Unitree Go1** (quadruped).
+- **Unitree G1** (humanoid).
+
+These robots serve as:
+
+- Minimal examples for **robot integration**.
+- Stable, well-tested baselines for **benchmark tasks**.
+
+To keep the core library lean, we do **not** plan to aggressively expand the
+built-in robot library. Additional robots may be provided in separate
+repositories or community-maintained packages.
+
+Can I use USD or URDF models?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+No, mjlab expects **MJCF (MuJoCo XML)** models.
+
+- You will need to **convert** USD or URDF assets to MJCF.
+- For many common robots, you can directly use
+  `MuJoCo Menagerie <https://github.com/google-deepmind/mujoco_menagerie>`_,
+  which ships high-quality MJCF models and assets.
+
+Getting Help
+------------
+
+GitHub Issues
+~~~~~~~~~~~~~
+
+Use GitHub issues for:
+
+- **Bug reports**
+- **Performance regressions**
+- **Documentation gaps**
+
+When filing a bug, please include:
+
+- CUDA driver and runtime versions
+- GPU model
+- A minimal reproduction script
+- Complete error logs and stack traces
+- Appropriate labels (for example: ``bug``, ``performance``, ``docs``)
+
+`Open an issue <https://github.com/mujocolab/mjlab/issues>`_
+
+Discussions
+~~~~~~~~~~~
+
+Use GitHub Discussions for:
+
+- Usage questions (config, debugging, best practices)
+- Performance tuning tips
+- Asset conversion and modeling questions
+- Design discussions and roadmap ideas
+
+`Start a discussion <https://github.com/mujocolab/mjlab/discussions>`_
+
+Known Limitations
+-----------------
+
+We're tracking missing features for the stable release in
+https://github.com/mujocolab/mjlab/issues/100. Check our
+`open issues <https://github.com/mujocolab/mjlab/issues>`_ to see what's actively
+being worked on.
+
+If something isn't working or if we've missed something, please
+`file a bug report <https://github.com/mujocolab/mjlab/issues/new>`_.
\ No newline at end of file
diff --git a/docs/source/installation.rst b/docs/source/installation.rst
new file mode 100644
index 0000000..772842b
--- /dev/null
+++ b/docs/source/installation.rst
@@ -0,0 +1,233 @@
+.. _installation:
+
+Installation Guide
+==================
+
+This guide presents different installation paths so you can
+choose the one that best fits your use case.
+
+.. contents::
+   :local:
+   :depth: 1
+
+.. note::
+
+    **System Requirements**
+
+    - **Training**: Linux + NVIDIA GPU (CUDA 12.4+ recommended)
+    - **Evaluation**: Linux, macOS, or Windows (WSL)
+    - **Python**: 3.10 or higher
+
+    See :ref:`faq` for more details on what is exactly supported.
+
+
+How to choose an installation method?
+-------------------------------------
+
+Select the card that best matches how you plan to use ``mjlab``.
+
+.. grid:: 2
+   :gutter: 2
+
+   .. grid-item-card:: Method 1 - Use mjlab as a dependency (uv)
+      :link: install-uv-dependency
+      :link-type: ref
+
+      You are **using mjlab as a dependency** in your own project managed by ``uv``. **(Recommended for most users)**
+
+   .. grid-item-card:: Method 2 - Develop / contribute (uv)
+      :link: install-uv-develop
+      :link-type: ref
+
+      You are **trying mjlab** or **contributing to mjlab itself** directly from inside the mjlab repository, with ``uv`` managing the environment.
+
+   .. grid-item-card:: Method 3 - Classic pip / venv / conda
+      :link: install-pip
+      :link-type: ref
+
+      You are using **classic tools** (``pip`` / ``venv`` / ``conda``) and **do not use uv**.
+
+   .. grid-item-card:: Method 4 - Docker / clusters
+      :link: install-docker
+      :link-type: ref
+
+      You are **running in containers or on clusters** and prefer a **Docker-based** setup.
+
+
+.. _install-uv-dependency:
+
+Method 1 - Use mjlab as a dependency (uv)
+-----------------------------------------
+
+This is our recommended way to use ``mjlab``. You have
+your own project and want to use ``mjlab`` as a dependency
+using ``uv``.
+
+1. Install uv
+^^^^^^^^^^^^^
+
+If you do not have ``uv`` installed, run:
+
+.. code-block:: bash
+
+   curl -LsSf https://astral.sh/uv/install.sh | sh
+
+2. Initialize your project
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Initialize a managed Python project:
+
+.. code-block:: bash
+
+   # Create a new package-based project
+   uv init --package my_mjlab_project
+   cd my_mjlab_project
+
+3. Add mjlab dependencies
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+There are different options to add ``mjlab`` as a dependency.
+We recommend using the latest stable version from PyPI. If you need
+the latest features, use the direct GitHub installation. Finally, if you
+need to use a feature you have developed locally, use the local editable
+install. These options are interchangeable: you can switch at any time.
+
+.. tab-set::
+
+   .. tab-item:: PyPI
+
+      Once in your project, install the latest snapshot from PyPI:
+
+      .. code:: bash
+
+         uv add mjlab
+
+   .. tab-item:: Source
+
+      Once in your project, install directly from GitHub without cloning:
+
+      .. code:: bash
+
+         uv add "mjlab @ git+https://github.com/mujocolab/mjlab"
+
+   .. tab-item:: Local
+
+      Clone the repository:
+
+      .. code:: bash
+
+         git clone https://github.com/mujocolab/mjlab.git
+
+      Once in your project, add it as an editable dependency:
+
+      .. code:: bash
+
+         uv add --editable /path/to/cloned/mjlab
+
+.. tip::
+
+   For a complete example of how to structure a project that integrates a custom robot
+   with an existing ``mjlab`` task, check out the
+   `ANYmal C Velocity Tracking <https://github.com/mujocolab/anymal_c_velocity>`_ repository.
+
+Verification
+^^^^^^^^^^^^
+
+After installation, verify that ``mjlab`` is working by running the demo:
+
+.. code-block:: bash
+
+   uv run demo
+
+
+.. _install-uv-develop:
+
+Method 2 - Develop / contribute (uv)
+------------------------------------
+
+This method is for developing ``mjlab`` itself or contributing to the project.
+
+.. code:: bash
+
+   git clone https://github.com/mujocolab/mjlab.git && cd mjlab
+   uv sync
+
+Verification
+^^^^^^^^^^^^
+
+After installation, verify that ``mjlab`` is working by running the demo:
+
+.. code-block:: bash
+
+   uv run demo
+
+
+.. _install-pip:
+
+Method 3 - Classic pip / venv / conda
+-------------------------------------
+
+Activate your virtual environment (``venv``, ``conda``, etc.), then install:
+
+.. code:: bash
+
+   pip install mjlab
+
+
+Verification
+^^^^^^^^^^^^
+
+After installation, verify that ``mjlab`` is working by running the demo:
+
+.. code-block:: bash
+
+   demo
+
+
+.. _install-docker:
+
+Method 4 - Docker / clusters
+----------------------------
+
+Prerequisites:
+
+- Install Docker: `Docker installation guide <https://docs.docker.com/engine/install/>`_.
+- Install an appropriate NVIDIA driver for your system and the
+  `NVIDIA Container Toolkit <https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html>`_.
+
+  - Be sure to register the container runtime with Docker and restart,
+    as described in the Docker configuration section of the NVIDIA
+    install guide.
+
+.. tab-set::
+
+   .. tab-item:: Pre-built image (recommended)
+
+      Pull and run the latest image from the GitHub Container Registry:
+
+      .. code-block:: bash
+
+         docker run --rm --runtime=nvidia --gpus all \
+           ghcr.io/mujocolab/mjlab uv run demo
+
+      The image is rebuilt on every push to ``main``.
+
+   .. tab-item:: Local build
+
+      Build from source and run:
+
+      .. code-block:: bash
+
+         ./scripts/run_docker.sh uv run demo
+
+
+Having some troubles?
+---------------------
+
+1. **Check the FAQ**
+
+    Consult the mjlab :ref:`faq` for answers to common installation and runtime issues
+
+2. **Still stuck?**
+
+    Open an issue on GitHub: https://github.com/mujocolab/mjlab/issues
diff --git a/docs/source/metrics.rst b/docs/source/metrics.rst
new file mode 100644
index 0000000..175fad0
--- /dev/null
+++ b/docs/source/metrics.rst
@@ -0,0 +1,110 @@
+.. _metrics:
+
+Metrics
+=======
+
+The metrics manager logs per-step scalar values as episode averages. Unlike
+rewards, metrics carry no weight and are not scaled by the step duration.
+They exist purely for diagnostics: tracking quantities such as tracking
+error, contact forces, or energy consumption alongside reward curves
+without influencing the optimization.
+
+Metrics are computed every environment step, accumulated per environment,
+and averaged over the episode length when the environment resets. The
+resulting averages are written to the training logger (TensorBoard or
+Weights & Biases) under the ``Episode_Metrics/`` prefix.
+
+If the ``metrics`` dictionary on ``ManagerBasedRlEnvCfg`` is empty, the
+environment substitutes a lightweight no-op manager with zero overhead.
+
+
+Registration
+------------
+
+Each metric term is registered by name in the ``metrics`` dictionary of
+``ManagerBasedRlEnvCfg``. The configuration is minimal: a callable and an
+optional ``params`` dictionary.
+
+.. code-block:: python
+
+    from mjlab.managers.metrics_manager import MetricsTermCfg
+
+    metrics = {
+        "base_height": MetricsTermCfg(
+            func=base_height,
+            params={"asset_cfg": SceneEntityCfg("robot")},
+        ),
+    }
+
+The callable receives ``env`` as its first argument and any entries in
+``params`` as keyword arguments. It must return a tensor of shape
+``[num_envs]``, one scalar per environment per step.
+
+
+How metrics are computed
+-------------------------
+
+The manager maintains a running sum and a step counter for each
+environment. On every call to ``compute()``:
+
+1. The step counter increments for all environments.
+2. Each term function is called with the current environment state.
+3. The returned per-environment values are added to the running sums.
+
+When an environment resets, the manager reduces each term's accumulated
+values to a scalar, averages the result across all resetting environments,
+and returns it under the key ``Episode_Metrics/<term_name>``. The sums and
+counters are then zeroed for the reset environments.
+
+The reduction is controlled by the ``reduce`` field on ``MetricsTermCfg``:
+
+- ``"mean"`` (default): divides the accumulated sum by the step count for
+  each environment. Division is per-environment, so environments that
+  terminated early are not diluted by longer-running ones.
+- ``"last"``: reports the value from the final step of the episode. This is
+  useful for binary success metrics (such as whether the robot is standing)
+  that should not be averaged over time.
+- ``"max"``: reports the highest value seen during the episode, useful for
+  peak quantities such as maximum power draw or contact force.
+- ``"sum"``: reports the accumulated total over the episode without dividing
+  by the step count. Use it for quantities that are inherently cumulative,
+  such as episodic reward or total distance traveled. Note that the value
+  grows with episode length, so it is not comparable across episodes of
+  differing duration.
+
+These scalars flow through ``env.extras["log"]`` into the training runner,
+which writes them to the configured logger. In a typical training run they
+appear as:
+
+.. code-block:: text
+
+    Episode_Metrics/base_height
+    Episode_Metrics/contact_force
+
+alongside the ``Episode_Reward/`` entries produced by the reward manager.
+
+
+Writing custom metric functions
+--------------------------------
+
+A metric function follows the same pattern as reward and observation
+functions. It takes the environment as its first argument, reads whatever
+state it needs, and returns a ``[num_envs]`` tensor.
+
+.. code-block:: python
+
+    import torch
+    from mjlab.envs import ManagerBasedRlEnv
+    from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+    def base_height(
+        env: ManagerBasedRlEnv,
+        asset_cfg: SceneEntityCfg = SceneEntityCfg("robot"),
+    ) -> torch.Tensor:
+        robot = env.scene[asset_cfg.name]
+        return robot.data.root_link_pos_w[:, 2]
+
+For metrics that require cached setup or per-episode state, implement the
+term as a class with ``__init__(self, cfg, env)`` and a ``__call__``
+method. If the class defines a ``reset(env_ids)`` method, the manager
+calls it automatically on episode resets.
diff --git a/docs/source/migration_isaac_lab.rst b/docs/source/migration_isaac_lab.rst
new file mode 100644
index 0000000..c08b061
--- /dev/null
+++ b/docs/source/migration_isaac_lab.rst
@@ -0,0 +1,285 @@
+.. _migration_isaac_lab:
+
+Migrating from Isaac Lab
+========================
+
+.. warning::
+
+   This guide is a work in progress. As more users migrate, we will update this
+   page with additional patterns and edge cases. If something is not covered,
+   please open an issue on GitHub or start a discussion:
+
+   - Issues: https://github.com/mujocolab/mjlab/issues
+   - Discussions: https://github.com/mujocolab/mjlab/discussions
+
+TL;DR
+-----
+
+Most Isaac Lab *manager-based* task configs can be ported to ``mjlab`` with
+only small changes:
+
+- The overall **MDP structure is the same** (managers for rewards, observations,
+  actions, commands, terminations, events, curriculum).
+- The **environment base classes are similar**, but naming is slightly
+  different.
+- The biggest change is **configuration style**: Isaac Lab uses nested
+  ``@configclass`` definitions; ``mjlab`` uses dictionaries of config objects.
+
+If you are familiar with Isaac Lab's manager-based API, migration is mostly
+mechanical.
+
+Key Differences
+---------------
+
+1. Import Paths
+~~~~~~~~~~~~~~~
+
+Isaac Lab:
+
+.. code-block:: python
+
+   from isaaclab.envs import ManagerBasedRLEnv
+
+mjlab:
+
+.. code-block:: python
+
+   from mjlab.envs import ManagerBasedRlEnvCfg
+
+.. note::
+
+   ``mjlab`` uses a consistent ``CamelCase`` naming convention (for example,
+   ``RlEnv`` instead of ``RLEnv``).
+
+2. Configuration Structure
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Isaac Lab uses nested ``@configclass`` blocks for manager terms. ``mjlab``
+instead uses **plain dictionaries** mapping names to config objects, which makes
+it easy to construct variants, merge configs, or generate them programmatically.
+For the full context behind this design decision, see
+`PR #292 <https://github.com/mujocolab/mjlab/pull/292>`_.
+
+**Isaac Lab:**
+
+.. code-block:: python
+
+   @configclass
+   class RewardsCfg:
+       """Reward terms for the MDP."""
+
+       motion_global_anchor_pos = RewTerm(
+           func=mdp.motion_global_anchor_position_error_exp,
+           weight=0.5,
+           params={"command_name": "motion", "std": 0.3},
+       )
+       motion_global_anchor_ori = RewTerm(
+           func=mdp.motion_global_anchor_orientation_error_exp,
+           weight=0.5,
+           params={"command_name": "motion", "std": 0.4},
+       )
+
+**mjlab:**
+
+.. code-block:: python
+
+   rewards = {
+       "motion_global_anchor_pos": RewardTermCfg(
+           func=mdp.motion_global_anchor_position_error_exp,
+           weight=0.5,
+           params={"command_name": "motion", "std": 0.3},
+       ),
+       "motion_global_anchor_ori": RewardTermCfg(
+           func=mdp.motion_global_anchor_orientation_error_exp,
+           weight=0.5,
+           params={"command_name": "motion", "std": 0.4},
+       ),
+   }
+
+   cfg = ManagerBasedRlEnvCfg(
+       scene=scene,
+       rewards=rewards,
+       # ... other manager dictionaries:
+       # observations=..., actions=..., commands=..., terminations=...,
+       # events=..., curriculum=...
+   )
+
+This pattern applies to all managers:
+
+- ``rewards``
+- ``observations``
+- ``actions``
+- ``commands``
+- ``terminations``
+- ``events``
+- ``curriculum``
+
+3. Scene Configuration
+~~~~~~~~~~~~~~~~~~~~~~
+
+Scene setup is **simpler** in ``mjlab``:
+
+- No Omniverse / USD scene graph, no ``prim_path`` management.
+- Assets are pure MuJoCo (MJCF) with modifier dataclasses applied to
+  ``mujoco.MjSpec``.
+- Lights, materials, textures, and sensors are configured as part of
+  ``SceneCfg`` and robot configs.
+
+**Isaac Lab:**
+
+.. code-block:: python
+
+   from whole_body_tracking.robots.g1 import G1_ACTION_SCALE, G1_CYLINDER_CFG
+   from isaaclab.scene import InteractiveSceneCfg
+   from isaaclab.sensors import ContactSensorCfg
+   from isaaclab.terrains import TerrainImporterCfg
+   import isaaclab.sim as sim_utils
+   from isaaclab.assets import ArticulationCfg, AssetBaseCfg
+
+   @configclass
+   class MySceneCfg(InteractiveSceneCfg):
+       """Configuration for the terrain scene with a legged robot."""
+
+       # ground terrain
+       terrain = TerrainEntityCfg(
+           prim_path="/World/ground",
+           terrain_type="plane",
+           collision_group=-1,
+           physics_material=sim_utils.RigidBodyMaterialCfg(
+               friction_combine_mode="multiply",
+               restitution_combine_mode="multiply",
+               static_friction=1.0,
+               dynamic_friction=1.0,
+           ),
+           visual_material=sim_utils.MdlFileCfg(
+               mdl_path="{NVIDIA_NUCLEUS_DIR}/Materials/Base/Architecture/Shingles_01.mdl",
+               project_uvw=True,
+           ),
+       )
+       # lights
+       light = AssetBaseCfg(
+           prim_path="/World/light",
+           spawn=sim_utils.DistantLightCfg(
+               color=(0.75, 0.75, 0.75), intensity=3000.0
+           ),
+       )
+       sky_light = AssetBaseCfg(
+           prim_path="/World/skyLight",
+           spawn=sim_utils.DomeLightCfg(
+               color=(0.13, 0.13, 0.13), intensity=1000.0
+           ),
+       )
+       robot = G1_CYLINDER_CFG.replace(prim_path="{ENV_REGEX_NS}/Robot")
+
+**mjlab:**
+
+.. code-block:: python
+
+   from dataclasses import replace
+
+   from mjlab.scene import SceneCfg
+   from mjlab.asset_zoo.robots.unitree_g1.g1_constants import get_g1_robot_cfg
+   from mjlab.utils.spec_config import ContactSensorCfg
+   from mjlab.terrains import TerrainEntityCfg
+
+   # Configure contact sensor
+   self_collision_sensor = ContactSensorCfg(
+       name="self_collision",
+       subtree1="pelvis",
+       subtree2="pelvis",
+       data=("found",),
+       reduce="netforce",
+       num=10,  # report up to 10 contacts
+   )
+
+   # Add sensor to robot config
+   g1_cfg = replace(get_g1_robot_cfg(), sensors=(self_collision_sensor,))
+
+   # Create scene
+   SCENE_CFG = SceneCfg(
+       terrain=TerrainEntityCfg(terrain_type="plane"),
+       entities={"robot": g1_cfg},
+   )
+
+Key changes:
+
+- No USD ``prim_path`` or cloning; the scene is described directly in MuJoCo.
+- Materials, lights, and visual properties are applied via
+  ``MjSpec``-modifier dataclasses.
+- See ``mjlab.utils.spec_config`` in the repository for helpers that apply
+  these changes for you.
+- ``asset_name`` has been unified to ``entity_name`` across all configurations.
+
+Complete Example Comparison
+---------------------------
+
+A good way to learn the pattern is to compare concrete tasks that have already
+been ported:
+
+- Isaac Lab implementation (Beyond Mimic):
+
+  - https://github.com/HybridRobotics/whole_body_tracking/blob/main/source/whole_body_tracking/whole_body_tracking/tasks/tracking/tracking_env_cfg.py
+
+- mjlab implementation:
+
+  - https://github.com/mujocolab/mjlab/blob/main/src/mjlab/tasks/tracking/tracking_env_cfg.py
+
+You will see that:
+
+- Manager dictionaries in ``mjlab`` mirror Isaac Lab's config classes,
+- Reward, observation, command, and termination logic is almost identical,
+- Scene and asset setup are simplified to pure MuJoCo.
+
+Migration Checklist
+-------------------
+
+Use this as a quick checklist when porting a task:
+
+1. **Base class and imports**
+
+   - Replace Isaac Lab imports (for example,
+     ``from isaaclab.envs import ManagerBasedRLEnv``) with the corresponding
+     ``mjlab`` imports (for example,
+     ``from mjlab.envs import ManagerBasedRlEnvCfg``).
+
+2. **Manager configuration**
+
+   - Convert each Isaac Lab ``@configclass`` manager (``RewardsCfg``,
+     ``ObservationsCfg``, etc.) into a dictionary of config objects.
+   - Pass these dictionaries into ``ManagerBasedRlEnvCfg``.
+
+3. **Scene and assets**
+
+   - Replace ``InteractiveSceneCfg`` with a ``SceneCfg`` instance.
+   - Replace USD / ``prim_path`` logic with MuJoCo asset configs and scene
+     entities (for example, a robot from ``asset_zoo``).
+
+4. **Sensors and contact handling**
+
+   - Convert Isaac Lab ``ContactSensorCfg`` to
+     ``mjlab.utils.spec_config.ContactSensorCfg`` and attach it to the robot
+     config.
+
+5. **RL entry points**
+
+   - Make sure your training script or entry point uses the correct task id and
+     environment config (for example, via Gymnasium registration or direct
+     construction, depending on how your project is structured).
+
+Tips and Support
+----------------
+
+1. Check the examples in the repository under:
+
+   - ``src/mjlab/tasks/``
+
+2. If you get stuck:
+
+   - Open an issue: https://github.com/mujocolab/mjlab/issues
+   - Start a discussion: https://github.com/mujocolab/mjlab/discussions
+
+3. Keep in mind MuJoCo vs Isaac Sim differences:
+
+   - Some Omniverse / USD rendering features do not have direct equivalents.
+   - Focus first on matching the **physics and observations**, then polish
+     visuals if needed.
diff --git a/docs/source/motivation.rst b/docs/source/motivation.rst
new file mode 100644
index 0000000..e5972db
--- /dev/null
+++ b/docs/source/motivation.rst
@@ -0,0 +1,88 @@
+.. _motivation:
+
+Why mjlab?
+==========
+
+Reinforcement learning has become a powerful tool for training robot
+controllers in simulation and transferring them to real hardware. The
+fidelity of this pipeline hinges on getting simulation details right.
+
+Several frameworks address this.
+`Isaac Lab <https://github.com/isaac-sim/IsaacLab>`_
+provides a comprehensive manager-based API for composing RL environments,
+but requires the Omniverse runtime, which adds installation complexity and
+startup latency.
+`MuJoCo Playground <https://playground.mujoco.org/>`_ takes the opposite
+approach: minimal
+abstractions and monolithic environment definitions that are easy to hack
+and quick to prototype, but code duplication across robots and tasks makes
+multi-task codebases difficult to maintain. There remains a gap for a
+framework that is both lightweight and built on a proven orchestration API
+with access to best-in-class physics.
+
+mjlab fills this gap. It adopts Isaac Lab's manager-based design, where
+users compose self-contained building blocks for observations, rewards,
+events, and commands, and pairs it with MuJoCo Warp for GPU-accelerated
+physics simulation. The result is a framework with minimal dependencies,
+fast startup, direct access to native MuJoCo model and data structures,
+and a PyTorch-native interface for policy training.
+
+
+Design philosophy
+-----------------
+
+mjlab is designed around three core engineering commitments:
+
+1. **Minimal installation friction.** A single
+   ``uvx --from mjlab --refresh demo`` command is enough to run the
+   framework. No heavyweight runtimes, no multi-gigabyte downloads. The
+   dependency footprint is kept intentionally small.
+
+2. **Transparent and inspectable physics.** mjlab targets a single physics
+   stack, MuJoCo Warp, to prioritize simulation transparency and
+   debuggability. The framework exposes MuJoCo-native ``MjModel`` and
+   ``MjData`` structures for direct inspection and state access.
+   Cross-simulator portability is a non-goal; mjlab favors precise control
+   and interpretability over backend generality.
+
+3. **Tight MuJoCo ecosystem integration.** Users work directly with MuJoCo
+   models and conventions. MJCF files, MuJoCo Menagerie assets, and
+   standard MuJoCo tooling all work without translation layers.
+
+
+Scope
+-----
+
+mjlab provides infrastructure for rigid-body robot learning. It includes
+depth and raycast sensors for geometric perception. High-fidelity RGB
+rendering is out of scope. This does not preclude vision-based policies:
+a common approach is to train privileged policies using full state, then
+distill into vision-based controllers using external rendering.
+
+The framework is intended to be extended to custom robots, tasks, sensors,
+and actuators. It ships with reference implementations of velocity tracking,
+motion imitation, and manipulation tasks.
+
+
+Comparison
+----------
+
+.. list-table::
+   :header-rows: 1
+   :widths: 25 25 50
+
+   * - Framework
+     - Strengths
+     - Best for
+   * - **mjlab**
+     - Lightweight, fast iteration, native MuJoCo, PyTorch
+     - MuJoCo users who want structured RL environments with GPU acceleration
+   * - **Isaac Lab**
+     - Photorealistic rendering, USD pipeline, Omniverse ecosystem
+     - Projects that need Isaac Sim capabilities
+   * - **MuJoCo Playground**
+     - Minimal abstractions, easy to hack, quick prototyping
+     - One-off experiments and rapid iteration on single tasks
+   * - **Newton**
+     - Multi-physics solvers (deformables, VBD), differentiable simulation
+     - Projects that need solver flexibility beyond rigid-body MuJoCo
diff --git a/docs/source/observations.rst b/docs/source/observations.rst
new file mode 100644
index 0000000..b077d10
--- /dev/null
+++ b/docs/source/observations.rst
@@ -0,0 +1,287 @@
+.. _observations:
+
+Observations
+============
+
+Observations define what the agent perceives at each step. The
+observation manager assembles individual observation terms into the
+tensor the policy receives as input. Each term passes through a
+configurable processing pipeline: noise injection, clipping, scaling,
+sensor delay, and history stacking.
+
+
+Observation groups
+------------------
+
+Each group is an ``ObservationGroupCfg`` that holds a ``terms`` dict
+mapping string names to ``ObservationTermCfg`` entries. The manager
+concatenates term outputs in registration order along the last dimension.
+
+.. code-block:: python
+
+    from mjlab.managers.observation_manager import (
+        ObservationGroupCfg,
+        ObservationTermCfg,
+    )
+    from mjlab.envs.mdp import observations as obs_fns
+
+    observations = {
+        "policy": ObservationGroupCfg(
+            terms={
+                "base_lin_vel": ObservationTermCfg(func=obs_fns.base_lin_vel),
+                "base_ang_vel": ObservationTermCfg(func=obs_fns.base_ang_vel),
+                "projected_gravity": ObservationTermCfg(
+                    func=obs_fns.projected_gravity
+                ),
+                "joint_pos": ObservationTermCfg(func=obs_fns.joint_pos_rel),
+                "joint_vel": ObservationTermCfg(func=obs_fns.joint_vel_rel),
+                "last_action": ObservationTermCfg(func=obs_fns.last_action),
+            },
+            enable_corruption=True,
+        ),
+    }
+
+This dictionary is passed to ``ManagerBasedRlEnvCfg(observations=...)``.
+The observation manager resolves term functions at initialization and
+allocates any required history or delay buffers at that point.
+
+By default, term outputs within a group are concatenated along the last
+dimension into a single ``[num_envs, D]`` tensor. Set
+``concatenate_terms=False`` to receive a dict mapping term names to
+individual tensors instead.
+
+The ``enable_corruption`` flag gates noise application for the entire
+group: when ``False``, noise configs on individual terms are ignored.
+This makes it straightforward to share term definitions between a noisy
+actor group and a noise-free critic group, as shown in the
+:ref:`asymmetric actor-critic <obs-asymmetric>` section below.
+
+History and delay can also be set at the group level to apply uniformly
+across all terms; see :ref:`obs-history-delay`.
+
+
+Processing pipeline
+-------------------
+
+Each step, every term in every group passes through the following
+pipeline in order:
+
+.. code-block:: text
+
+    compute → noise → clip → scale → delay → history
+
+1. **compute**: the term function is called. It must return a
+   ``[num_envs, D]`` tensor.
+
+2. **noise**: if ``enable_corruption=True`` on the group and the term
+   has a ``noise`` config, noise is applied. Stateless noise
+   (``NoiseCfg``) is applied directly; stateful noise (``NoiseModelCfg``)
+   is maintained by the manager across steps.
+
+3. **clip**: if ``clip=(lo, hi)`` is set on the term, values are clamped
+   to that range.
+
+4. **scale**: if ``scale`` is set, the output is multiplied
+   element-wise. Accepts a scalar, a tuple, or a tensor.
+
+5. **delay**: if ``delay_max_lag > 0``, the term's output is stored in a
+   ring buffer and a value from an earlier step is returned. See
+   :ref:`obs-history-delay`.
+
+6. **history**: if ``history_length > 0``, past outputs are stacked.
+   See :ref:`obs-history-delay`.
+
+.. note::
+
+   Delay is applied before history. This models real systems where old
+   sensor readings are buffered: the history stacks delayed observations,
+   not future ones.
+
+
+.. _obs-history-delay:
+
+Observation history and delay
+------------------------------
+
+Observations support two temporal features: history and delay. History
+stacks past frames to give the policy temporal context; delay models
+sensor latency by returning observations from earlier timesteps.
+
+Both are configured per term via fields on ``ObservationTermCfg``.
+They can also be set at the group level on ``ObservationGroupCfg``,
+which applies uniformly to all terms in the group. Term-level settings
+override group-level settings.
+
+History
+^^^^^^^
+
+Setting ``history_length=N`` stacks the N most recent outputs of a term.
+When ``flatten_history_dim=True`` (the default), the history dimension
+is folded into the feature dimension, producing a ``[num_envs, N * D]``
+tensor suitable for MLPs. When ``flatten_history_dim=False``, the output
+retains the time dimension as ``[num_envs, N, D]``, suitable for RNNs.
+
+History buffers are cleared on environment reset. The first observation
+after reset is backfilled across all history slots, so the policy
+receives valid data from step zero.
+
+When ``flatten_history_dim=True`` and ``concatenate_terms=True``, mjlab
+uses **term-major** ordering: each term's full history is flattened
+before concatenating across terms.
+
+.. code-block:: text
+
+    Term A (D=4, history=3), Term B (D=2, history=3):
+    [A_t0, A_t1, A_t2, B_t0, B_t1, B_t2]
+     └─ A history ──┘  └─ B history ─┘
+
+Some frameworks use **time-major** ordering instead, where full frames
+are built at each timestep before concatenating across time. Transferring
+policies between frameworks with different orderings requires reindexing
+the observation vector.
+
+Delay
+^^^^^
+
+Setting ``delay_max_lag > 0`` enables a ring buffer that stores past
+outputs and returns one from an earlier step. The lag is sampled
+uniformly from ``[delay_min_lag, delay_max_lag]`` in integer steps.
+A lag of zero returns the current observation; a lag of two returns the
+observation from two steps ago.
+
+.. code-block:: text
+
+    50Hz control (20ms/step), lag=2:
+
+    Sensor captures:  A     B     C     D     E     F     G     H
+    Control steps:    0     1     2     3     4     5     6     7
+
+    Policy sees:      A     A     A     B     C     D     E     F
+                      └clamp┘     └ 40ms delay from here on
+
+    Steps 0-1: lag clamped because the buffer is not yet full.
+    Step 2 onward: each step returns the observation from 2 steps ago.
+
+To convert real-world latency to lag steps:
+``lag = latency_seconds / step_dt``. At 50 Hz control (20 ms per step),
+a 40 ms sensor latency corresponds to a lag of 2. Delays are quantized
+to integer steps; to approximate a latency that falls between steps, set
+``delay_min_lag`` and ``delay_max_lag`` to the two nearest integers.
+
+By default each environment samples its own lag independently
+(``delay_per_env=True``). Additional parameters control resampling
+frequency (``delay_update_period``), hold probability
+(``delay_hold_prob``), and phase staggering
+(``delay_per_env_phase``).
+
+Both history and delay buffers are allocated only when enabled; terms
+with default settings incur no overhead.
+
+
+Built-in observation functions
+--------------------------------
+
+The functions below live in ``mjlab.envs.mdp.observations`` (also
+re-exported as ``mjlab.envs.mdp``). All return ``[num_envs, D]``
+tensors.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 26 74
+
+   * - Function
+     - Description
+   * - ``base_lin_vel``
+     - Linear velocity of the robot base in the base frame.
+   * - ``base_ang_vel``
+     - Angular velocity of the robot base in the base frame.
+   * - ``projected_gravity``
+     - Gravity vector projected into the base frame. Provides roll and
+       pitch information without an explicit orientation representation.
+   * - ``joint_pos_rel``
+     - Joint positions relative to the default pose. Pass
+       ``biased=True`` for encoder-biased positions (for sim2real with
+       ``dr.encoder_bias``).
+   * - ``joint_vel_rel``
+     - Joint velocities relative to the default velocities.
+   * - ``last_action``
+     - The most recent action tensor. Optionally pass ``action_name``
+       to select a single action term.
+   * - ``generated_commands``
+     - The current command tensor from a named command term. Requires
+       ``params={"command_name": "<name>"}``.
+   * - ``builtin_sensor``
+     - Raw data from a named ``BuiltinSensor`` (MuJoCo ``sensordata``
+       slice). Requires ``params={"sensor_name": "<entity>/<sensor>"}``.
+   * - ``height_scan``
+     - Height above each raycast hit point from a ``RayCastSensor``.
+       Requires ``params={"sensor_name": "<name>"}``.
+
+For ``builtin_sensor`` and ``height_scan``, the ``sensor_name`` parameter
+must match a sensor registered in the scene. See :ref:`sensors` for how
+to configure sensors.
+
+
+.. _obs-asymmetric:
+
+Asymmetric actor-critic
+-----------------------
+
+Multiple observation groups enable asymmetric actor-critic
+architectures. The actor group contains only the observations that
+would be available on real hardware; the critic group can include
+privileged simulation state that is only accessible during training.
+
+The velocity locomotion task uses this pattern. The actor group
+receives noisy IMU readings and joint state; the critic group adds
+noise-free height scan data and foot contact information. The
+``enable_corruption`` flag makes this separation clean: actor terms
+carry noise configs but the critic group disables them entirely.
+
+.. code-block:: python
+
+    observations = {
+        "actor": ObservationGroupCfg(
+            terms=actor_terms,
+            concatenate_terms=True,
+            enable_corruption=True,   # Noise active during training.
+        ),
+        "critic": ObservationGroupCfg(
+            terms={**actor_terms, **privileged_terms},
+            concatenate_terms=True,
+            enable_corruption=False,  # No noise on critic.
+        ),
+    }
+
+The training framework receives both groups. The policy network reads
+``obs["actor"]`` at inference time; the value network reads
+``obs["critic"]`` during training only.
+
+
+Writing custom observation functions
+--------------------------------------
+
+An observation function accepts ``env`` as its first argument and
+returns a ``[num_envs, D]`` tensor. Additional parameters are declared
+as function arguments and supplied via
+``ObservationTermCfg(params={...})``.
+
+.. code-block:: python
+
+    import torch
+    from mjlab.envs import ManagerBasedRlEnv
+    from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+
+    def my_observation(
+        env: ManagerBasedRlEnv,
+        asset_cfg: SceneEntityCfg = SceneEntityCfg("robot"),
+    ) -> torch.Tensor:
+        robot = env.scene[asset_cfg.name]
+        return robot.data.root_lin_vel_b
+
+When a term needs to cache setup work or maintain per-episode state,
+implement it as a class with ``__init__(self, cfg, env)`` and
+``__call__(self, env, ...)``. If the class has a ``reset(env_ids)``
+method, the manager calls it automatically on episode resets. See
+:ref:`env-config-term-pattern` for the general pattern.
diff --git a/docs/source/randomization.rst b/docs/source/randomization.rst
new file mode 100644
index 0000000..ade0878
--- /dev/null
+++ b/docs/source/randomization.rst
@@ -0,0 +1,1436 @@
+.. _domain_randomization:
+
+Domain Randomization
+====================
+
+Domain randomization varies physical parameters during training so that policies
+are robust to modeling errors and real-world variation. This guide shows
+how to attach randomization terms to an environment using ``EventTermCfg`` and
+the ``dr`` module.
+
+Quick Start
+-----------
+
+Use an ``EventTermCfg`` that calls a typed function from ``dr`` with a
+**value range** and an **operation** describing how to apply the draw.
+
+.. code-block:: python
+
+    from mjlab.envs.mdp import dr
+    from mjlab.managers.event_manager import EventTermCfg
+    from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+    foot_friction: EventTermCfg = EventTermCfg(
+        mode="reset",  # randomize each episode
+        func=dr.geom_friction,
+        params={
+            "asset_cfg": SceneEntityCfg("robot", geom_names=[".*_foot.*"]),
+            "ranges": (0.3, 1.2),
+            "operation": "abs",
+        },
+    )
+
+Each ``dr`` function is decorated with ``@requires_model_fields`` which
+automatically tracks the fields that need to be expanded for per-world
+storage **and** the ``RecomputeLevel`` needed to keep
+:ref:`derived quantities <dr-recomputation>` consistent.
+
+The ``mode`` parameter controls when the event fires:
+
+* ``"startup"`` randomizes once at initialization
+* ``"reset"`` randomizes at every episode reset
+* ``"interval"`` randomizes at regular time intervals
+
+
+Available Functions
+-------------------
+
+Model field functions
+^^^^^^^^^^^^^^^^^^^^^
+
+Each function writes to a single field on ``sim.model`` (the MuJoCo Warp
+model). For example, ``dr.geom_friction`` writes to ``sim.model.geom_friction``,
+``dr.body_mass`` writes to ``sim.model.body_mass``, and so on. Most share the
+signature ``(env, env_ids, ranges, ...)``, with ``distribution`` and
+``operation`` controlling sampling and application (see :ref:`dr-parameters`).
+Some functions have a more readable name than the underlying MuJoCo field; in
+those cases the raw field name is available as an alias (``dr.body_com_offset``
+and ``dr.body_ipos`` are the same function).
+
+.. rubric:: Geom fields
+
+.. list-table::
+   :header-rows: 1
+   :widths: 28 18 34 20
+
+   * - Function
+     - MuJoCo field
+     - Description
+     - Notes
+   * - ``dr.geom_friction``
+     - ``geom_friction``
+     - Sliding, torsional, and rolling friction coefficients
+     - Default axis: 0 (tangential only)
+   * - ``dr.geom_pos``
+     - ``geom_pos``
+     - Position of the geom in the parent body frame
+     -
+   * - ``dr.geom_quat``
+     - ``geom_quat``
+     - Orientation of the geom frame
+     - Accepts roll/pitch/yaw ranges (radians); composes with default
+   * - ``dr.geom_rgba``
+     - ``geom_rgba``
+     - Color and transparency (RGBA)
+     -
+   * - ``dr.geom_size``
+     - ``geom_size``
+     - Geom-specific size parameters (radius, half-lengths, etc.)
+     - Automatically recomputes ``geom_rbound`` and ``geom_aabb``
+   * - ``dr.geom_matid``
+     - ``geom_matid``
+     - Which baked material the geom renders with
+     - Samples uniformly from ``asset_cfg.material_names``
+
+.. rubric:: Body fields
+
+.. list-table::
+   :header-rows: 1
+   :widths: 28 18 34 20
+
+   * - Function
+     - MuJoCo field
+     - Description
+     - Notes
+   * - ``dr.body_mass``
+     - ``body_mass``
+     - Mass of the body
+     - Triggers ``set_const`` recomputation
+   * - ``dr.body_com_offset`` (alias ``body_ipos``)
+     - ``body_ipos``
+     - Center of mass position relative to the body frame
+     - Triggers ``set_const``
+   * - ``dr.body_pos``
+     - ``body_pos``
+     - Position of the body frame in the parent frame
+     - Triggers ``set_const_0``
+   * - ``dr.body_quat``
+     - ``body_quat``
+     - Orientation of the body frame
+     - Accepts roll/pitch/yaw ranges (radians); composes with default;
+       triggers ``set_const_0``
+
+.. rubric:: Joint fields
+
+.. list-table::
+   :header-rows: 1
+   :widths: 28 18 34 20
+
+   * - Function
+     - MuJoCo field
+     - Description
+     - Notes
+   * - ``dr.joint_damping`` (alias ``dof_damping``)
+     - ``dof_damping``
+     - Velocity-proportional damping force (passive)
+     -
+   * - ``dr.joint_armature`` (alias ``dof_armature``)
+     - ``dof_armature``
+     - Added rotor inertia (models geared transmissions)
+     - Triggers ``set_const_0``
+   * - ``dr.joint_friction`` (alias ``dof_frictionloss``)
+     - ``dof_frictionloss``
+     - Dry friction loss in the joint
+     -
+   * - ``dr.joint_stiffness`` (alias ``jnt_stiffness``)
+     - ``jnt_stiffness``
+     - Spring stiffness pulling toward the reference position
+     -
+   * - ``dr.joint_limits`` (alias ``jnt_range``)
+     - ``jnt_range``
+     - Lower and upper joint position limits
+     -
+   * - ``dr.joint_default_pos`` (alias ``qpos0``)
+     - ``qpos0``
+     - Reference joint position (zero-spring equilibrium)
+     - Triggers ``set_const_0``
+
+.. rubric:: Site fields
+
+.. list-table::
+   :header-rows: 1
+   :widths: 28 18 34 20
+
+   * - Function
+     - MuJoCo field
+     - Description
+     - Notes
+   * - ``dr.site_pos``
+     - ``site_pos``
+     - Position of the site frame in the parent body frame
+     -
+   * - ``dr.site_quat``
+     - ``site_quat``
+     - Orientation of the site frame
+     - Accepts roll/pitch/yaw ranges (radians); composes with default
+
+.. rubric:: Camera fields
+
+.. list-table::
+   :header-rows: 1
+   :widths: 28 18 34 20
+
+   * - Function
+     - MuJoCo field
+     - Description
+     - Notes
+   * - ``dr.cam_fovy``
+     - ``cam_fovy``
+     - Vertical field of view (degrees)
+     -
+   * - ``dr.cam_pos``
+     - ``cam_pos``
+     - Camera position in the parent body frame
+     -
+   * - ``dr.cam_quat``
+     - ``cam_quat``
+     - Camera orientation
+     - Accepts roll/pitch/yaw ranges (radians); composes with default
+   * - ``dr.cam_intrinsic``
+     - ``cam_intrinsic``
+     - Focal length and principal point ``[fx, fy, cx, cy]``
+     -
+
+.. rubric:: Light fields
+
+.. list-table::
+   :header-rows: 1
+   :widths: 28 18 34 20
+
+   * - Function
+     - MuJoCo field
+     - Description
+     - Notes
+   * - ``dr.light_pos``
+     - ``light_pos``
+     - Light position in the parent body frame
+     -
+   * - ``dr.light_dir``
+     - ``light_dir``
+     - Light direction vector
+     -
+   * - ``dr.light_diffuse``
+     - ``light_diffuse``
+     - Diffuse RGB color
+     -
+   * - ``dr.light_specular``
+     - ``light_specular``
+     - Specular RGB color
+     -
+   * - ``dr.light_ambient``
+     - ``light_ambient``
+     - Ambient RGB color
+     -
+   * - ``dr.light_attenuation``
+     - ``light_attenuation``
+     - Constant, linear, and quadratic attenuation coefficients
+     -
+   * - ``dr.light_cutoff``
+     - ``light_cutoff``
+     - Spot light half-cone angle in degrees
+     - Ignored for directional lights
+   * - ``dr.light_exponent``
+     - ``light_exponent``
+     - Spot light angular falloff exponent
+     - Ignored for directional lights
+
+.. rubric:: Material fields
+
+.. list-table::
+   :header-rows: 1
+   :widths: 28 18 34 20
+
+   * - Function
+     - MuJoCo field
+     - Description
+     - Notes
+   * - ``dr.mat_rgba``
+     - ``mat_rgba``
+     - Material RGBA color (tints textures)
+     -
+   * - ``dr.mat_emission``
+     - ``mat_emission``
+     - Self-illumination multiplier
+     - Used by MuJoCo Warp RGB rendering
+   * - ``dr.mat_specular``
+     - ``mat_specular``
+     - Specular reflection strength in ``[0, 1]``
+     - Scales the MuJoCo Warp RGB specular component
+   * - ``dr.mat_shininess``
+     - ``mat_shininess``
+     - Surface shininess in ``[0, 1]``
+     - Used by MuJoCo Warp RGB rendering
+   * - ``dr.mat_texrepeat``
+     - ``mat_texrepeat``
+     - Texture repeat in the S/T directions
+     - Only affects textured materials; values should stay positive
+   * - ``dr.mat_texid``
+     - ``mat_texid``
+     - Texture assigned to a material's ``mjtTextureRole`` slot (RGB by
+       default)
+     - Samples uniformly from ``asset_cfg.texture_names``. Use ``role`` to
+       target a different texture role.
+
+.. rubric:: Contact pair fields
+
+.. list-table::
+   :header-rows: 1
+   :widths: 28 18 34 20
+
+   * - Function
+     - MuJoCo field
+     - Description
+     - Notes
+   * - ``dr.pair_friction``
+     - ``pair_friction``
+     - Per-pair friction override ``[tangent1, tangent2, spin, roll1, roll2]``
+     - Default axis: 0 (tangent1, requires ``condim >= 3``). Use
+       ``isotropic=True`` to mirror tangent2 = tangent1 (and roll2 = roll1).
+       Overrides per-geom friction for explicitly defined
+       `<contact><pair> <https://mujoco.readthedocs.io/en/stable/XMLreference.html#contact-pair>`_
+       elements. See :ref:`dr-pair-friction`.
+
+.. rubric:: Tendon fields
+
+.. list-table::
+   :header-rows: 1
+   :widths: 28 18 34 20
+
+   * - Function
+     - MuJoCo field
+     - Description
+     - Notes
+   * - ``dr.tendon_damping``
+     - ``tendon_damping``
+     - Velocity-proportional damping along the tendon
+     -
+   * - ``dr.tendon_stiffness``
+     - ``tendon_stiffness``
+     - Spring stiffness along the tendon
+     -
+   * - ``dr.tendon_friction`` (alias ``tendon_frictionloss``)
+     - ``tendon_frictionloss``
+     - Dry friction loss along the tendon
+     -
+   * - ``dr.tendon_armature``
+     - ``tendon_armature``
+     - Inertia associated with tendon velocity
+     - Triggers ``set_const_0``
+
+Entity-level functions
+^^^^^^^^^^^^^^^^^^^^^^
+
+The functions above all write to a single ``sim.model`` field. The functions
+below operate at the mjlab entity level instead, because they touch multiple
+model fields at once or modify entity state that doesn't live on the MuJoCo
+model.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 25 75
+
+   * - Function
+     - What it does
+   * - ``dr.pseudo_inertia``
+     - Physics-consistent joint randomization of ``body_mass``,
+       ``body_ipos``, ``body_inertia``, and ``body_iquat`` via the
+       pseudo-inertia matrix parameterization (Rucker & Wensing 2022).
+       Guarantees a positive-definite inertia tensor and positive mass.
+       See :ref:`dr-pseudo-inertia` for details.
+   * - ``dr.pd_gains``
+     - Randomizes stiffness (kp) and damping (kd) together. For
+       ``BuiltinPositionActuator`` and ``XmlActuator`` it writes to
+       ``actuator_gainprm`` and ``actuator_biasprm``. For
+       ``IdealPdActuator`` it sets gains on the entity directly. All three
+       support inline delay fields.
+   * - ``dr.effort_limits``
+     - Randomizes actuator force range (``actuator_forcerange``). For
+       ``IdealPdActuator`` also updates the entity's internal force limit.
+       Supports ``BuiltinPositionActuator``, ``XmlActuator``, and
+       ``IdealPdActuator``.
+   * - ``dr.encoder_bias``
+     - Adds a fixed per-joint bias to position readings, simulating encoder
+       calibration errors. Writes to ``entity.data.encoder_bias``, not the
+       MuJoCo model.
+
+
+.. _dr-pseudo-inertia:
+
+Pseudo-inertia randomization
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``dr.pseudo_inertia`` jointly randomizes ``body_mass``, ``body_ipos``,
+``body_inertia``, and ``body_iquat`` while guaranteeing physical consistency
+for any perturbation magnitude. Unlike randomizing these fields independently
+(which can produce negative masses, imaginary principal moments, or
+triangle-inequality violations), ``pseudo_inertia`` parameterizes inertia
+through the *pseudo-inertia matrix* :math:`J \succ 0` and ensures the result
+is always physically valid.
+
+The pseudo-inertia matrix :math:`J` is a :math:`4 \times 4` symmetric
+positive-definite matrix that encodes mass, center of mass, and the full
+rotational inertia tensor in a single object:
+
+.. math::
+
+   J = \begin{bmatrix}
+     \Sigma & h \\
+     h^\top & m
+   \end{bmatrix}, \qquad
+   \Sigma = \tfrac{1}{2}\operatorname{tr}(I)\,I_3 - I, \qquad
+   h = m\,c
+
+where :math:`m` is mass (``body_mass``), :math:`c` is the center of mass
+(``body_ipos``), :math:`d` is the vector of principal inertia moments
+(``body_inertia``), and :math:`I` is the :math:`3 \times 3` inertia tensor
+at the body-frame origin. The inertia tensor is constructed by rotating the
+diagonal principal moments into the body frame and applying the
+parallel-axis theorem:
+
+.. math::
+
+   I_{\text{com}} &= V \operatorname{diag}(d)\, V^\top,
+   \qquad V = R(q)^\top \\
+   I &= I_{\text{com}} + m\bigl(\lVert c \rVert^2 I_3 - c\,c^\top\bigr)
+
+where :math:`q` is the body-to-principal-frame quaternion (``body_iquat``)
+and :math:`R(q)` is its rotation matrix.
+
+The math follows `Rucker & Wensing, "Smooth Parameterization of Rigid-Body
+Inertia," IEEE RA-L 2022 <https://par.nsf.gov/servlets/purl/10347458>`_.
+:math:`J` is factored via Cholesky as :math:`J = LL^\top`. A perturbation
+is applied through an upper-triangular matrix :math:`U`:
+
+.. math::
+
+   J' = (UL)(UL)^\top
+
+which is guaranteed positive definite for any :math:`U`. The perturbed
+inertia tensor is then decomposed back into MuJoCo fields: the inverse
+parallel-axis theorem shifts :math:`I` back to the COM, and
+eigendecomposition extracts the principal moments (``body_inertia``) and
+principal-frame rotation (``body_iquat``). This is exact for any
+perturbation magnitude.
+
+The 10 parameters of :math:`U` control different physical effects:
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 80
+
+   * - Parameter
+     - Physical effect
+   * - ``alpha``
+     - Global mass-density log-scale. Mass and all principal inertia moments
+       scale by :math:`e^{2\alpha}`. Center of mass is unchanged.
+   * - ``d1, d2, d3``
+     - Axis-aligned stretch/compress along x, y, z in the inertia frame.
+       Use ``d_range`` to set all three to the same range (isotropic).
+   * - ``s12, s13, s23``
+     - Shear perturbation in the xy, xz, and yz planes. Redistributes
+       mass asymmetrically; produces off-diagonal inertia contributions.
+   * - ``t1, t2, t3``
+     - Shifts the center of mass along x, y, z (body frame). For a pure
+       ``t1`` shift, mass is unchanged and ``body_ipos[0]`` shifts by
+       exactly ``t1``. Use ``t_range`` to set all three to the same range.
+
+.. rubric:: Example
+
+.. code-block:: python
+
+    events = {
+        # Isotropic mass scaling + small COM variation.
+        "body_inertia_dr": EventTermCfg(
+            mode="reset",
+            func=dr.pseudo_inertia,
+            params={
+                "asset_cfg": SceneEntityCfg("robot", body_names=["torso"]),
+                "alpha_range": (-0.1, 0.1),   # ±10% mass/inertia scaling
+                "t_range": (-0.02, 0.02),     # ±2 cm COM shift
+            },
+        ),
+        # Anisotropic stretching (x stiffer than y/z).
+        "body_inertia_aniso_dr": EventTermCfg(
+            mode="startup",
+            func=dr.pseudo_inertia,
+            params={
+                "asset_cfg": SceneEntityCfg("robot", body_names=[".*"]),
+                "alpha_range": (-0.2, 0.2),
+                "d1_range": (-0.1, 0.1),
+                "d2_range": (-0.3, 0.3),
+                "d3_range": (-0.3, 0.3),
+            },
+        ),
+    }
+
+
+.. _dr-safety:
+
+Safety of Runtime Model Changes
+-------------------------------
+
+In C MuJoCo, modifying ``mjModel`` fields at runtime can be unsafe: some
+changes invalidate internal acceleration structures (BVH) or leave derived
+quantities stale. MuJoCo Warp has a different collision pipeline, so many of
+these concerns do not apply.
+
+Two architectural differences matter most:
+
+1. **No collision BVH.** C MuJoCo builds a static bounding-volume hierarchy
+   (BVH) for midphase collision pruning. Changing ``body_pos``/``body_quat``
+   of a static body invalidates that tree. MuJoCo Warp uses NxN or
+   sweep-and-prune broadphase instead, so there is no static tree to
+   invalidate.
+
+2. **Local bounding boxes.** ``geom_aabb`` in MuJoCo Warp is a *local*
+   bounding box (center + half-size in the geom frame). The broadphase
+   transforms it to world space every step using ``geom_xpos``/``geom_xmat``
+   from forward kinematics. In C MuJoCo, the BVH caches world-space bounds,
+   so any change to ``geom_pos``/``geom_quat`` makes them stale.
+
+The table below shows which fields are safe to randomize in mjlab and how
+that compares to C MuJoCo.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 22 20 20 38
+
+   * - Field(s)
+     - C MuJoCo
+     - mjlab / MuJoCo Warp
+     - Why the difference
+   * - ``body_pos``, ``body_quat``
+     - Safe with ``mj_setConst``, but **unsafe for static bodies**
+       (invalidates midphase BVH)
+     - **Safe** with ``set_const_0``
+     - No collision BVH to invalidate (see above). Body FK runs for
+       all bodies regardless of ``body_treeid``. See the
+       :ref:`static-body caveat <dr-static-body-caveat>` below.
+   * - ``body_mass``, ``body_inertia``, ``body_ipos``, ``body_iquat``
+     - Safe with ``mj_setConst``
+     - **Safe** with ``set_const``
+     - Same approach. ``dr.pseudo_inertia`` jointly randomizes all
+       four while guaranteeing physical consistency.
+   * - ``geom_pos``, ``geom_quat``
+     - **Unsafe** (no ``mj_setConst`` support)
+     - **Safe** for geoms on dynamic bodies
+     - FK recomputes ``geom_xpos``/``geom_xmat`` every step from
+       ``geom_pos``/``geom_quat``, and local ``geom_aabb`` stays
+       valid (see above). See the
+       :ref:`static-body caveat <dr-static-body-caveat>` below.
+   * - ``geom_size``
+     - **Unsafe**
+     - **Safe** (recomputes bounds automatically)
+     - ``dr.geom_size`` recomputes ``geom_rbound`` and ``geom_aabb``
+       inline after writing new sizes. Only primitive types (sphere,
+       capsule, ellipsoid, cylinder, box) are supported.
+   * - ``geom_rbound``, ``geom_aabb``
+     - **Unsafe** (internal derived quantities)
+     - **Not randomized** (derived)
+     - Broadphase acceleration data. Only set once during model
+       loading. Would need recomputation if ``geom_size`` changes.
+   * - ``geom_friction``, ``geom_rgba``
+     - Safe
+     - **Safe**
+     - No derived quantities. Contact friction is read directly each
+       step.
+   * - ``dof_armature``
+     - Safe with ``mj_setConst``
+     - **Safe** with ``set_const_0``
+     - Same approach.
+   * - ``dof_damping``, ``dof_frictionloss``, ``jnt_stiffness``,
+       ``jnt_range``
+     - Safe
+     - **Safe**
+     - No derived quantities.
+   * - ``qpos0``
+     - Safe with ``mj_setConst``
+     - **Safe** with ``set_const_0``
+     - Same approach.
+   * - ``tendon_stiffness``, ``tendon_damping``, ``tendon_frictionloss``
+     - Mostly safe (``mj_setConst`` if changing from/to zero)
+     - **Safe**
+     - MuJoCo Warp does not use the sleep mechanism that makes the
+       zero/non-zero transition special in C MuJoCo.
+   * - ``tendon_armature``
+     - Safe with ``mj_setConst``
+     - **Safe** with ``set_const_0``
+     - Contributes to the mass matrix via ``smooth.tendon_armature()``.
+       Same approach as ``dof_armature``.
+   * - ``actuator_gainprm``, ``actuator_biasprm``
+     - Mostly safe (``mj_setConst`` for dampratio actuators)
+     - **Safe**
+     - mjlab's ``dr.pd_gains`` handles dampratio internally.
+   * - ``site_pos``, ``site_quat``
+     - Mostly safe (``mj_setConst`` for tracking cameras/lights)
+     - **Safe**
+     - Sites are recomputed via FK. No tracking camera concern in
+       typical RL usage.
+   * - ``bvh_aabb``, ``oct_aabb``, ``oct_coeff``
+     - **Unsafe**
+     - Not applicable / not randomized
+     - MuJoCo Warp uses BVH only for rendering, not collision. Octree
+       data (``oct_*``) is used for SDF collision and should not be
+       modified.
+
+.. _dr-static-body-caveat:
+
+.. admonition:: Static-body caveat for ``geom_pos``/``geom_quat`` and
+   ``body_pos``/``body_quat``
+
+   MuJoCo Warp's forward kinematics skips geoms that are both
+   **world-welded** (``body_weldid == 0``) and **not descended from a mocap
+   body** (``body_mocapid[root] == -1``). For such geoms,
+   ``geom_xpos``/``geom_xmat`` are computed once during ``make_data`` and
+   never updated. Changing ``geom_pos`` or the parent ``body_pos`` would
+   leave the world-space collision position stale.
+
+   In practice this affects only bare ``<geom>`` elements placed directly on
+   the ``<worldbody>`` in XML (e.g. a ground plane) that are not part of any
+   mjlab entity.  All mjlab entities (including fixed-base ones) are
+   auto-wrapped in a mocap body by ``auto_wrap_fixed_base_mocap``, which
+   makes them exempt from the FK skip.  The built-in ``dr`` functions target
+   named bodies/geoms on entities, so they are always safe.
+
+.. _dr-geom-size:
+
+How ``geom_size`` recomputation works
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Changing ``geom_size`` at runtime requires updating two derived fields that
+the broadphase reads every step:
+
+- ``geom_rbound``: bounding sphere radius (used for sphere-filter pruning)
+- ``geom_aabb``: local axis-aligned bounding box (used for AABB/OBB pruning)
+
+Both are copied from ``MjModel`` during model loading and never recomputed
+by MuJoCo Warp. ``dr.geom_size`` handles this by recomputing both fields
+inline (pure PyTorch, no Warp kernel needed) after writing the new sizes.
+
+The formulas are type-dependent:
+
+.. list-table::
+   :header-rows: 1
+   :widths: 18 30 30
+
+   * - Geom type
+     - ``geom_rbound``
+     - ``geom_aabb`` half-size
+   * - Sphere
+     - ``s[0]``
+     - ``(s[0], s[0], s[0])``
+   * - Capsule
+     - ``s[0] + s[1]``
+     - ``(s[0], s[0], s[0] + s[1])``
+   * - Cylinder
+     - ``sqrt(s[0]² + s[1]²)``
+     - ``(s[0], s[0], s[1])``
+   * - Ellipsoid
+     - ``max(s[0], s[1], s[2])``
+     - ``(s[0], s[1], s[2])``
+   * - Box
+     - ``sqrt(s[0]² + s[1]² + s[2]²)``
+     - ``(s[0], s[1], s[2])``
+
+Plane, heightfield, mesh, and SDF geoms are not supported because their bounds
+come from vertex data or are infinite, not derivable from ``geom_size``.
+
+
+.. _dr-pair-friction:
+
+``pair_friction`` and isotropic friction
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``pair_friction`` stores five friction coefficients per contact pair:
+
+.. list-table::
+   :header-rows: 1
+   :widths: 10 20 20 50
+
+   * - Index
+     - Name
+     - Active when
+     - Meaning
+   * - 0
+     - tangent1
+     - ``condim >= 3``
+     - Sliding friction along the first tangent axis of the contact frame
+   * - 1
+     - tangent2
+     - ``condim >= 3``
+     - Sliding friction along the second tangent axis
+   * - 2
+     - spin
+     - ``condim >= 4``
+     - Torsional friction around the contact normal
+   * - 3
+     - roll1
+     - ``condim = 6``
+     - Rolling friction around the first tangent axis
+   * - 4
+     - roll2
+     - ``condim = 6``
+     - Rolling friction around the second tangent axis
+
+MuJoCo's standard geom friction is a 3-vector ``[tangential, torsional,
+rolling]`` that is automatically expanded to the 5-vector by replicating the
+tangential coefficient into tangent1 and tangent2, and the rolling coefficient
+into roll1 and roll2. For pair overrides the five values are stored
+independently, so the symmetry must be maintained explicitly. Pass
+``isotropic=True`` to enforce this: after sampling, tangent2 is overwritten
+with tangent1, and roll2 is overwritten with roll1 whenever axes 3 or 4 are
+targeted.
+
+**Recommendations by condim.**
+
+**condim = 3.** Both tangent axes are active. Sample tangent1 and set tangent2 equal to it with ``isotropic=True``. Pass
+``shared_random=True`` so that all pairs selected by ``asset_cfg`` receive the
+same sampled value within each environment (environments still get independent
+values from one another):
+
+.. code-block:: python
+
+   dr.pair_friction(
+       env,
+       env_ids=None,
+       ranges=(0.4, 1.0),
+       operation="abs",
+       asset_cfg=SceneEntityCfg("robot", pair_names=("foot1_floor", "foot2_floor")),
+       axes=[0],           # sample tangent1
+       shared_random=True, # all pairs selected by asset_cfg share one value per env
+       isotropic=True,     # tangent2 = tangent1
+   )
+
+**condim = 4.** Spin (axis 2) is additionally active. Randomize sliding
+friction as above. If spin should also be randomized, do so in a separate
+call with its own range:
+
+.. code-block:: python
+
+   dr.pair_friction(
+       env,
+       env_ids=None,
+       ranges=(0.4, 1.0),
+       operation="abs",
+       asset_cfg=SceneEntityCfg("robot", pair_names=("foot1_floor", "foot2_floor")),
+       axes=[0],
+       shared_random=True,
+       isotropic=True,
+   )
+   dr.pair_friction(
+       env,
+       env_ids=None,
+       ranges=(0.003, 0.01),
+       operation="abs",
+       asset_cfg=SceneEntityCfg("robot", pair_names=("foot1_floor", "foot2_floor")),
+       axes=[2],
+       shared_random=True,
+   )
+
+**condim = 6.** All five axes are active. Randomize sliding friction as above.
+To also randomize rolling friction symmetrically, target axis 3 with
+``isotropic=True`` so that roll2 is set equal to roll1:
+
+.. code-block:: python
+
+   dr.pair_friction(
+       env,
+       env_ids=None,
+       ranges=(0.4, 1.0),
+       operation="abs",
+       asset_cfg=SceneEntityCfg("robot", pair_names=("foot1_floor", "foot2_floor")),
+       axes=[0],
+       shared_random=True,
+       isotropic=True,
+   )
+   dr.pair_friction(
+       env,
+       env_ids=None,
+       ranges=(0.0001, 0.001),
+       operation="abs",
+       asset_cfg=SceneEntityCfg("robot", pair_names=("foot1_floor", "foot2_floor")),
+       axes=[3],
+       shared_random=True,
+       isotropic=True,  # roll2 = roll1
+   )
+
+
+Fields without ``dr`` functions
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Added as needed
+""""""""""""""""
+
+These continuous model fields could use a standard ``dr.*`` function but
+do not have one yet. They will be added as demand arises.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 40 40
+
+   * - Category
+     - Field(s)
+     - Notes
+   * - Body
+     - ``body_gravcomp``
+     - Gravity compensation weight. Needs ``set_const_fixed``.
+   * - Joint / DOF
+     - ``jnt_margin``
+     - Distance threshold for joint-limit detection.
+   * - Tendon
+     - ``tendon_range``
+     - Tendon length limits.
+   * -
+     - ``tendon_margin``
+     - Distance threshold for tendon-limit detection.
+   * -
+     - ``tendon_lengthspring``
+     - Spring rest-length range.
+   * - Actuator
+     - ``actuator_dynprm``, ``actuator_gear``,
+       ``actuator_ctrlrange``, ``actuator_actrange``
+     - ``pd_gains`` and ``effort_limits`` cover common cases.
+
+Better as custom code
+"""""""""""""""""""""
+
+These fields have coupled semantics that make a generic ``dr.*`` function
+more misleading than helpful. For example, ``solref`` is interpreted
+differently depending on the solver type (elliptic vs. direct), ``solimp``
+has ordering constraints (dmin < dmax, width > 0), and ``qpos_spring`` is
+coupled with ``qpos0``. The right ranges depend on the specific modeling
+choices. Write a custom event term instead (see
+:ref:`Custom Class-Based Event Terms <dr-custom-event-terms>` or use
+``@requires_model_fields`` to handle field expansion automatically).
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 40 40
+
+   * - Category
+     - Field(s)
+     - Notes
+   * - Solver parameters
+     - ``geom_solref``, ``geom_solimp``, ``geom_solmix``,
+       ``jnt_solref``, ``jnt_solimp``, ``dof_solref``,
+       ``dof_solimp``, ``pair_solref``, ``pair_solimp``,
+       ``eq_solref``, ``eq_solimp``
+     - Semantics depend on solver type and timestep.
+   * - Contact thresholds
+     - ``geom_margin``, ``geom_gap``, ``pair_margin``, ``pair_gap``
+     - Interact with solver parameters above.
+   * - Pair overrides
+     - ``eq_data``
+     - Constraint anchor overrides.
+   * - Spring reference
+     - ``qpos_spring``
+     - Coupled with ``qpos0``; randomizing independently is
+       error-prone.
+
+Requires dedicated API
+""""""""""""""""""""""
+
+These fields need specialized handling because they are integer/categorical,
+involve vertex data, or lack the per-world dimension needed for independent
+per-environment values.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 40 40
+
+   * - Category
+     - Field(s)
+     - Notes
+   * - Mesh
+     - ``mesh_vert``, ``mesh_normal``, ``mesh_face``, etc.
+     - Shape variation for manipulation objects. These fields
+       lack the per-world dimension, so per-world variation is
+       not possible with the current expand infrastructure.
+       Heterogeneous-world support is
+       `in progress <https://github.com/google-deepmind/mujoco_warp/pull/1009>`_.
+   * - Deformable
+     - ``flex_*``
+     - Deformable body parameters for soft-object manipulation.
+       Like mesh fields, most ``flex_*`` fields lack the per-world
+       dimension.
+
+Not a DR target
+""""""""""""""""
+
+- ``light_active``, ``light_castshadow``, ``light_type``,
+  ``cam_projection``: boolean/integer toggles, not continuous parameters.
+- ``jnt_pos``, ``jnt_axis``: structural joint geometry; changing at
+  runtime is fragile and not a standard use case.
+- ``hfield_data``, ``hfield_size``: terrain data; use the terrain
+  system instead.
+
+
+.. _dr-parameters:
+
+Parameters
+----------
+
+The model field functions share three parameters that control randomization:
+``distribution`` controls how values are sampled from ``ranges``, and
+``operation`` controls how those sampled values are applied to the model field.
+(Entity-level functions like ``dr.pseudo_inertia`` and ``dr.pd_gains`` have
+their own signatures; see their docstrings for details.)
+
+Distribution
+^^^^^^^^^^^^
+
+The ``distribution`` parameter controls how random values are sampled from
+the provided ``ranges``. It accepts a built-in string or a
+``dr.Distribution`` instance for custom sampling logic.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 25 75
+
+   * - Value
+     - Behavior
+   * - ``"uniform"`` (default)
+     - Samples uniformly between ``ranges[0]`` and ``ranges[1]``
+   * - ``"log_uniform"``
+     - Samples in log space, useful for parameters that span orders of
+       magnitude (e.g. torsional friction). Both range values must be > 0.
+   * - ``"gaussian"``
+     - ``ranges`` is interpreted as ``(mean, std)``
+
+To define a custom distribution, create a ``dr.Distribution`` instance. The
+``sample`` callable receives ``(lower, upper, shape, device)`` and returns a
+tensor. For example, a truncated normal that clamps samples to the given
+bounds:
+
+.. code-block:: python
+
+    import torch
+    from mjlab.envs.mdp import dr
+
+    truncated_normal = dr.Distribution(
+        name="truncated_normal",
+        sample=lambda lo, hi, shape, device: torch.clamp(
+            torch.normal(
+                mean=(lo + hi) / 2,
+                std=(hi - lo) / 4,  # 95% of samples within bounds
+            ).expand(shape),
+            min=lo,
+            max=hi,
+        ),
+    )
+
+    params={"distribution": truncated_normal, "ranges": (0.3, 1.2)}
+
+Operation
+^^^^^^^^^
+
+The ``operation`` parameter controls how the sampled value is applied to the
+model field. It accepts a built-in string or a ``dr.Operation`` instance
+for custom logic.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 25 75
+
+   * - Value
+     - Behavior
+   * - ``"abs"`` (default)
+     - Sets the field to the sampled value directly
+   * - ``"scale"``
+     - Multiplies the original default value by the sampled value
+   * - ``"add"``
+     - Adds the sampled value to the original default value
+
+For ``"scale"`` and ``"add"``, the DR engine always applies the random draw to
+the **original default values** captured from the compiled ``MjModel`` on CPU,
+not the current values. This prevents accumulation: scaling friction by 2x
+three times in a row gives 2x the original, not 8x.
+
+To define a custom operation, create a ``dr.Operation`` instance. The four
+fields are:
+
+- ``name``: a human-readable label for error messages.
+- ``initialize``: creates the result tensor that gets filled axis by axis
+  with sampled values. For example, ``scale`` starts from ones so that
+  unsampled axes multiply by 1 (no change), while ``add`` starts from zeros.
+- ``combine``: takes ``(base_values, random_values)`` and returns the final
+  tensor written into the model field. For example, ``scale`` returns
+  ``base * random`` and ``add`` returns ``base + random``.
+- ``uses_defaults``: when ``True``, the base values are the compile-time
+  defaults (preventing accumulation across repeated calls). When ``False``,
+  the base values are the current model values.
+
+As an example, the built-in ``add`` always adds to the *default* values, so
+repeated calls reset rather than drift. A custom ``drift`` operation that
+adds to the *current* values is useful for ``mode="interval"`` events where
+parameters should slowly wander over time:
+
+.. code-block:: python
+
+    import torch
+    from mjlab.envs.mdp import dr
+
+    drift = dr.Operation(
+        name="drift",
+        initialize=torch.zeros_like,
+        combine=torch.add,
+        uses_defaults=False,  # read current values, not defaults
+    )
+
+    # Friction slowly wanders each interval step.
+    friction_drift: EventTermCfg = EventTermCfg(
+        mode="interval",
+        interval_range_s=(0.5, 1.0),
+        func=dr.geom_friction,
+        params={
+            "asset_cfg": SceneEntityCfg("robot", geom_names=[".*_foot.*"]),
+            "ranges": (-0.01, 0.01),
+            "operation": drift,
+        },
+    )
+
+Axis selection
+^^^^^^^^^^^^^^
+
+Many model fields are multi-dimensional. For example, ``geom_friction`` has
+three components ``[tangential, torsional, rolling]`` and ``body_pos`` has
+three spatial axes ``[x, y, z]``. Specific axes can be targeted using the
+``axes`` parameter or by passing a dict for ``ranges``.
+
+For ``geom_friction`` with ``condim=3`` (standard frictional contact), only
+**axis 0 (tangential)** affects contact behavior. See the `MuJoCo contact
+documentation
+<https://mujoco.readthedocs.io/en/stable/computation/index.html#contact>`_
+for details on condim and friction coefficients.
+
+.. code-block:: python
+
+    # Tangential friction only (this is the default for geom_friction)
+    params={"ranges": {0: (0.3, 1.2)}}
+
+    # Tangential + torsional (torsional matters for condim >= 4)
+    params={"ranges": {0: (0.5, 1.0), 1: (0.001, 0.01)}}
+
+    # X and Y position with the same range
+    params={"axes": [0, 1], "ranges": (-0.1, 0.1)}
+
+Per-component string-keyed ranges
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Different ranges can be applied to different entities in a single call using
+regex patterns as dict keys:
+
+.. code-block:: python
+
+    dr.joint_damping(
+        env, env_ids,
+        ranges={".*knee.*": (0.5, 1.5), ".*hip.*": (0.8, 1.2)},
+        operation="scale",
+        asset_cfg=SceneEntityCfg("robot", joint_names=[".*"]),
+    )
+
+Each pattern is matched against the entity names (joint names, geom names, etc.)
+and the corresponding range is applied to the matching components. In this
+example, knee joints get their damping scaled by 0.5x to 1.5x while hip joints
+get a tighter 0.8x to 1.2x range, all in a single event term.
+
+
+Examples
+--------
+
+Friction (reset)
+^^^^^^^^^^^^^^^^
+
+.. code-block:: python
+
+    foot_friction: EventTermCfg = EventTermCfg(
+        mode="reset",
+        func=dr.geom_friction,
+        params={
+            "asset_cfg": SceneEntityCfg("robot", geom_names=[".*_foot.*"]),
+            "ranges": (0.3, 1.2),
+            "operation": "abs",
+        },
+    )
+
+.. note::
+
+     Give the robot's collision geoms higher **priority** than terrain
+     (geom priority defaults to 0). Then only robot
+     friction. MuJoCo will use the higher-priority geom's friction in
+     (robot, terrain) contacts.
+
+.. code-block:: python
+
+    from mjlab.utils.spec_config import CollisionCfg
+
+    robot_collision = CollisionCfg(
+        geom_names_expr=[".*_foot.*"],
+        contype=1,
+        conaffinity=1,
+        condim=3,
+        priority=1,
+        friction=(0.6,),
+    )
+
+
+Joint Offset (startup)
+^^^^^^^^^^^^^^^^^^^^^^
+
+Randomize default joint positions to simulate joint offset calibration errors:
+
+.. code-block:: python
+
+    joint_offset: EventTermCfg = EventTermCfg(
+        mode="startup",
+        func=dr.joint_default_pos,
+        params={
+            "asset_cfg": SceneEntityCfg("robot", joint_names=[".*"]),
+            "ranges": (-0.01, 0.01),
+            "operation": "add",
+        },
+    )
+
+
+Center of Mass (COM) (startup)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: python
+
+    com: EventTermCfg = EventTermCfg(
+        mode="startup",
+        func=dr.body_com_offset,
+        params={
+            "asset_cfg": SceneEntityCfg("robot", body_names=["torso"]),
+            "ranges": {0: (-0.02, 0.02), 1: (-0.02, 0.02)},
+            "operation": "add",
+        },
+    )
+
+
+Common Pitfalls
+---------------
+
+``dr.body_mass`` does not scale inertia
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Scaling mass without scaling inertia is only physically correct when modelling
+a point mass added at the COM (which contributes zero rotational inertia).
+For the common DR use case, simulating manufacturing variation or uncertainty
+in link density, mass and inertia should scale together. Use
+:func:`dr.pseudo_inertia` with ``alpha_range`` instead:
+
+.. code-block:: python
+
+    # Wrong: mass changes, inertia stays fixed (physically inconsistent).
+    EventTermCfg(func=dr.body_mass, params={"ranges": (0.8, 1.2)})
+
+    # Correct: mass and inertia both scale by e^{2alpha} (uniform density change).
+    EventTermCfg(func=dr.pseudo_inertia, params={"alpha_range": (-0.1, 0.1)})
+
+``dr.body_mass`` emits a ``UserWarning`` at runtime to flag this.
+
+``*_quat`` ranges are in radians, not degrees
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+All quaternion randomization functions (:func:`dr.geom_quat`,
+:func:`dr.body_quat`, :func:`dr.site_quat`, :func:`dr.cam_quat`) accept
+roll/pitch/yaw ranges in **radians**. Passing degree values silently produces
+rotations roughly 57x larger than intended. There is no runtime check.
+
+``*_quat`` perturbations are relative to the default, not the current value
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The sampled RPY perturbation is composed with the **default** quaternion, not
+the current one. This is consistent with the no-accumulation guarantee of all
+other ``dr`` functions, but it means repeated calls do not stack rotations.
+Each call independently samples a new perturbation from the default orientation.
+
+``dr.geom_friction`` only randomizes tangential friction by default
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The default axis is 0 (tangential friction). Axes 1 (torsional) and 2
+(rolling) only affect contacts with ``condim >= 4``, so the default is correct
+for standard ``condim=3`` contacts. If the model uses high-dimensional
+contacts, pass ``axes=[0, 1, 2]`` explicitly.
+
+``dr.geom_size`` raises on non-primitive geoms
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:func:`dr.geom_size` only supports primitive geom types (sphere, capsule,
+ellipsoid, cylinder, box) because broadphase bounds for mesh, plane, and
+heightfield geoms cannot be recomputed analytically. Selecting a non-primitive
+geom raises a ``ValueError``. Filter the ``SceneEntityCfg`` to primitive geoms
+only:
+
+.. code-block:: python
+
+    # Select only primitive geoms by name pattern.
+    geom_cfg = SceneEntityCfg("robot", geom_names=(".*sphere.*", ".*box.*"))
+
+How It Works Under the Hood
+---------------------------
+
+Understanding the internals helps when writing custom DR terms or debugging
+unexpected behavior.
+
+Per-world storage
+^^^^^^^^^^^^^^^^^
+
+MuJoCo Warp batches thousands of worlds into a single simulation. To save
+memory, model arrays like ``geom_friction`` are stored once with shape
+``(1, ngeom, 3)`` and a **stride of 0** along the first (world) dimension.
+GPU kernels index into these arrays with ``worldid % arr.shape[0]``. When
+``shape[0]`` is 1, every world reads the same row, so they all share identical
+model parameters.
+
+On the PyTorch side, mjlab wraps these stride-0 arrays using ``torch.expand``
+so they appear to have shape ``(num_envs, ngeom, 3)`` while still backed by a
+single row of memory. Indexing with ``tensor[env_id]`` makes it look like
+each world has its own data, but writes to any world affect all of them because
+they all point to the same underlying memory.
+
+To give each world independent values, the underlying Warp array is
+**expanded** from shape ``(1, N)`` to ``(num_worlds, N)`` with real
+per-world memory and normal strides. ``sim.expand_model_fields()``
+allocates a new array, copies the shared data into each world's row, and
+replaces the old array on the model. After expansion, writes to one world no
+longer affect others and each world can have its own friction, mass, or
+damping values.
+
+Each ``dr`` function declares which fields it needs via the
+``@requires_model_fields`` decorator, and the ``EventManager`` collects these
+at startup so expansion happens automatically. Custom DR terms that directly
+modify model arrays must ensure those arrays have been expanded. Either
+decorate the function with ``@requires_model_fields`` or call
+``sim.expand_model_fields()`` manually.
+
+.. note::
+
+   Expanding a field allocates new GPU memory and invalidates any captured CUDA
+   graph because the graph holds pointers to the old arrays. mjlab recreates
+   the graph automatically after expansion. This is a one-time cost at
+   environment startup, not per-episode.
+
+Why not just recompile the model?
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The cleanest way to get per-world variation would be to modify the ``MjSpec``
+for each world, compile each one into its own ``MjModel``, and transfer them all
+to the GPU. That would give perfectly consistent derived quantities for free
+because ``mj_setConst`` runs during compilation.
+
+mjlab does not do this for two reasons:
+
+1. **Cost.** Compiling an ``MjSpec`` is a CPU operation. Doing it once per world
+   on every episode reset would be far too slow for thousands of environments.
+
+2. **Architecture.** MuJoCo Warp expects a single ``Model`` shared across all
+   worlds. There is no mechanism to load N independent models into one
+   simulation.
+
+Instead, mjlab modifies the expanded arrays in place on the GPU and selectively
+recompute only the derived quantities that depend on what changed. This is
+what the ``RecomputeLevel`` system handles.
+
+.. _dr-recomputation:
+
+Recomputation of derived fields
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Some model fields are **derived** from others. For example,
+``body_subtreemass`` (the total mass of a body and all its descendants) depends
+on ``body_mass``. Changing ``body_mass`` without updating
+``body_subtreemass``, the constraint solver will use stale impedance values
+and the simulation will be subtly wrong.
+
+In C MuJoCo, the solution is to call `mj_setConst
+<https://mujoco.readthedocs.io/en/latest/programming/simulation.html#mjmodel-changes>`_
+after modifying model parameters at runtime. MuJoCo Warp provides an equivalent
+set of functions (``set_const``, ``set_const_0``, ``set_const_fixed``) that run
+on the GPU and operate on all worlds in parallel. mjlab calls these
+automatically.
+
+The three recomputation levels, from cheapest to most expensive:
+
+.. list-table::
+   :header-rows: 1
+   :widths: 25 35 40
+
+   * - Level
+     - What it recomputes
+     - When to use
+   * - ``set_const_fixed``
+     - ``body_subtreemass``
+     - After changing ``body_gravcomp``
+   * - ``set_const_0``
+     - ``dof_invweight0``, ``body_invweight0``, ``tendon_length0``,
+       ``tendon_invweight0``, ``actuator_acc0``, plus camera and light
+       references
+     - After changing ``dof_armature``, ``tendon_armature``,
+       ``body_inertia``, ``body_pos``, ``body_quat``, or ``qpos0``
+   * - ``set_const``
+     - Everything above
+     - After changing ``body_mass`` or ``body_ipos`` (center of mass)
+
+The built-in ``dr`` functions already declare the correct level. When the
+``EventManager`` fires multiple DR terms in a single ``apply()`` call, it
+tracks the strongest level among them and calls ``sim.recompute_constants()``
+once at the end. Manual calls are unnecessary unless writing
+custom DR logic.
+
+Fields that only affect contact or joint behavior directly (``geom_friction``,
+``dof_damping``, ``dof_frictionloss``, etc.) have no derived quantities and
+need no recomputation.
+
+.. note::
+
+   mjlab captures ``sim.step()``, ``sim.forward()``, ``sim.reset()``, and
+   ``sim.sense()`` as individual CUDA graphs for performance. All event
+   manager logic, including ``recompute_constants``, runs as regular
+   Python between these graph replays, so it will not break graph capture.
+
+   That said, ``set_const`` is expensive: it runs forward kinematics, the
+   composite rigid body algorithm, and mass matrix factorization across all
+   worlds. Calling it every step via an ``interval`` event would add
+   significant overhead. In practice, fields that need recomputation
+   (``body_mass``, ``body_com_offset``, ``joint_armature``, etc.) are best
+   randomized with ``startup`` or ``reset`` modes. Fields that need no
+   recomputation (``geom_friction``, ``dof_damping``, etc.) are cheap to
+   randomize at any frequency.
+
+
+.. _dr-custom-event-terms:
+
+Custom Class-Based Event Terms
+------------------------------
+
+Custom event terms can also use classes instead of functions. This is
+useful for event terms that need to maintain state or perform initialization
+logic:
+
+.. code-block:: python
+
+    class RandomizeTerrainFriction:
+        """Custom event term that randomizes terrain friction."""
+
+        def __init__(self, cfg, env):
+            # Find the terrain geom index during initialization
+            self._terrain_idx = None
+            for idx, geom in enumerate(env.scene.spec.geoms):
+                if geom.name == "terrain":
+                    self._terrain_idx = idx
+
+            if self._terrain_idx is None:
+                raise ValueError("Terrain geom not found in the model.")
+
+        def __call__(self, env, env_ids, ranges):
+            """Called each time the event is triggered."""
+            from mjlab.utils.math import sample_uniform
+            env.sim.model.geom_friction[env_ids, self._terrain_idx, 0] = (
+                sample_uniform(ranges[0], ranges[1], len(env_ids), env.device)
+            )
+
+
+    # Register in the environment config.
+    terrain_friction: EventTermCfg = EventTermCfg(
+        mode="reset",
+        func=RandomizeTerrainFriction,
+        params={"ranges": (0.3, 1.2)},
+    )
+
+
+Visualizing DR Changes
+----------------------
+
+Both viewers reflect DR changes, but with different coverage.
+
+**Native viewer**
+
+The native viewer syncs per-world model fields from the GPU to a local
+``MjModel`` before each render. All of MuJoCo's built-in visualization
+toggles then work correctly against the randomized model:
+
+- Geom appearance (``geom_rgba``, ``geom_size``, ``geom_pos``, ``geom_quat``,
+  ``geom_matid``)
+- Material appearance (``mat_rgba``, ``mat_emission``, ``mat_specular``,
+  ``mat_shininess``, ``mat_texrepeat``, ``mat_texid``)
+- Body and site poses (``body_pos``, ``body_quat``, ``body_ipos``,
+  ``site_pos``, ``site_quat``)
+- Inertia (``body_inertia``, ``body_iquat``, ``body_mass``): press ``I``
+  to toggle inertia boxes
+- Camera parameters (``cam_pos``, ``cam_quat``, ``cam_fovy``,
+  ``cam_intrinsic``): press ``Q`` to toggle camera frustums
+- Lights (``light_pos``, ``light_dir``, ``light_diffuse``, ``light_specular``,
+  ``light_ambient``, ``light_attenuation``, ``light_cutoff``,
+  ``light_exponent``)
+
+.. grid:: 2
+
+   .. grid-item-card::
+
+      .. image:: _static/dr_combined_rand.gif
+         :alt: Cube color, size, and link orientations randomized each reset
+
+      Cube color (``dr.geom_rgba``), cube size (``dr.geom_size``), and
+      link 2/3 orientations (``dr.body_quat``) randomized each episode
+      reset. Broadphase bounds are recomputed automatically after size
+      changes.
+
+   .. grid-item-card::
+
+      .. image:: _static/dr_pseudo_inertia.gif
+         :alt: Inertia ellipsoids resizing each episode reset
+
+      ``dr.pseudo_inertia`` with ``alpha_range=(-0.5, 0.5)`` on links 2
+      and 3. The inertia ellipsoids resize each episode reset while other
+      links remain unchanged.
+
+.. note::
+
+   ``cam_fovy`` has no effect on cameras that use intrinsic parameters
+   (``sensorsize`` / ``focal`` set in XML). This applies to both rendered
+   images and the frustum visualization. MuJoCo computes the projection
+   from ``cam_intrinsic`` and ``cam_sensorsize`` instead. Use
+   ``dr.cam_intrinsic`` to randomize the field of view for such cameras.
+   See the `MuJoCo camera documentation
+   <https://mujoco.readthedocs.io/en/stable/XMLreference.html#body-camera>`_
+   for details on how intrinsic parameters interact with ``fovy``.
+
+**Viser**
+
+Camera frustums and body poses are always current because viser reads
+world-space positions directly from GPU simulation data (``cam_xpos``,
+``body_xpos``) every frame.
+
+
+.. note::
+
+   ``geom_rgba``, ``geom_size`` and ``mat_texid`` DR are **not** reflected
+   in viser. Geom colors, sizes and textures are baked into the scene's
+   GLB meshes at construction time. The underlying viser API
+   (``add_batched_meshes_simple``) supports per-instance color updates via
+   ``batched_colors``, but this requires routing color-only geoms through
+   a different handle type than the current ``add_batched_meshes_trimesh``
+   path. Deferred for a future update.
+
+
+Migrating from Isaac Lab
+------------------------
+
+Isaac Lab exposes explicit friction combination modes (``multiply``, ``average``,
+``min``, ``max``). MuJoCo instead uses **priority-based selection**: if one
+contacting geom has higher ``priority``, its friction is used. Otherwise the
+**element-wise maximum** is used. See the
+`MuJoCo contact documentation <https://mujoco.readthedocs.io/en/stable/computation/index.html#contact>`_
+for details.
diff --git a/docs/source/recorders.rst b/docs/source/recorders.rst
new file mode 100644
index 0000000..a918b13
--- /dev/null
+++ b/docs/source/recorders.rst
@@ -0,0 +1,121 @@
+.. _recorders:
+
+Recorders
+=========
+
+The recorder manager provides lifecycle hooks for logging data during
+rollouts. Unlike rewards, recorders have no effect on the optimization
+loop. They exist purely to let you capture observations, actions, or any
+other environment state without modifying mjlab internals.
+
+Each recorder term is a class that you implement. mjlab calls its methods
+at the right moments and leaves all I/O decisions to you. If the ``recorders``
+dictionary on ``ManagerBasedRlEnvCfg`` is empty, the environment substitutes a
+lightweight no-op manager with zero overhead.
+
+
+Lifecycle hooks
+---------------
+
+The manager exposes three hooks per term:
+
+``record_pre_reset(env_ids)``
+    Called inside ``env.step()`` before terminated environments are reset.
+    ``obs_buf`` holds the observation from the end of the *previous* step
+    (the input the agent used to choose the terminal action, not the
+    post-action terminal state). ``action_manager.action`` holds the
+    terminal action and is still valid here; it will be zeroed for these
+    environments by ``_reset_idx`` immediately after. ``reward_buf`` holds
+    the terminal reward. This is the right place to record the terminal
+    transition ``(obs_t, action_t, reward_t, done=True)``.
+
+``record_post_reset(env_ids)``
+    Called after a reset completes and fresh observations are available.
+    Fires at the end of ``env.reset()`` (all environments) and within
+    ``env.step()`` after each batch of terminated environments is reset.
+    ``obs_buf[env_ids]`` holds the initial observation of the new episode;
+    ``action_manager.action[env_ids]`` is zero. Use this to initialize
+    per-episode state or record the first observation.
+
+``record_post_step()``
+    Called at the end of every ``env.step()`` with fresh observations.
+    For environments that reset during this step, ``action_manager.action``
+    has been zeroed and ``obs_buf`` holds the initial state of the new
+    episode rather than the post-action terminal observation. Use
+    ``record_pre_reset`` for those environments' terminal transitions and
+    ``self._env.reset_buf`` to identify which environments reset.
+
+``close()``
+    Called when the environment closes. Release file handles and flush
+    buffers here.
+
+
+Writing a recorder term
+------------------------
+
+Subclass :class:`~mjlab.managers.RecorderTerm` and override whichever
+hooks you need. The environment is available as ``self._env``, giving
+access to ``self._env.obs_buf``, ``self._env.action_manager.action``, and
+all other managers.
+
+.. code-block:: python
+
+    import csv
+    from mjlab.managers import RecorderTerm, RecorderTermCfg
+
+    class CsvRecorder(RecorderTerm):
+        def __init__(self, cfg, env):
+            super().__init__(cfg, env)
+            self._file = open(cfg.params["path"], "w", newline="")
+            self._writer = csv.writer(self._file)
+
+        def record_pre_reset(self, env_ids):
+            # Terminal transition: action is still intact here.
+            # It will be zeroed by _reset_idx immediately after this returns.
+            obs = self._env.obs_buf["actor"][env_ids].cpu().numpy()
+            act = self._env.action_manager.action[env_ids].cpu().numpy()
+            for o, a in zip(obs, act):
+                self._writer.writerow(o.tolist() + a.tolist())
+
+        def record_post_step(self):
+            # Skip envs that just reset: their terminal pair was written
+            # in record_pre_reset and their action is now zeroed.
+            mask = ~self._env.reset_buf
+            obs = self._env.obs_buf["actor"][mask].cpu().numpy()
+            act = self._env.action_manager.action[mask].cpu().numpy()
+            for o, a in zip(obs, act):
+                self._writer.writerow(o.tolist() + a.tolist())
+
+        def close(self):
+            self._file.close()
+
+The term receives the full ``cfg`` object so it can read any values you
+put in ``cfg.params``.
+
+
+Registration
+------------
+
+Add the term to the ``recorders`` dictionary on your environment config:
+
+.. code-block:: python
+
+    from dataclasses import dataclass, field
+    from mjlab.managers import RecorderTermCfg
+
+    @dataclass
+    class MyEnvCfg(SomeTaskEnvCfg):
+        recorders: dict = field(default_factory=lambda: {
+            "csv": RecorderTermCfg(
+                func=CsvRecorder,
+                params={"path": "rollout.csv"},
+            )
+        })
+
+Multiple terms can be registered under different keys and run together.
+
+.. note::
+
+    ``func`` must be a :class:`~mjlab.managers.RecorderTerm` subclass.
+    Function-based terms are not supported because recorder terms are
+    stateful.
diff --git a/docs/source/research.rst b/docs/source/research.rst
new file mode 100644
index 0000000..709ce62
--- /dev/null
+++ b/docs/source/research.rst
@@ -0,0 +1,87 @@
+.. _research:
+
+Research
+========
+
+Citing mjlab
+------------
+
+If you use mjlab in your research, please cite:
+
+.. code-block:: bibtex
+
+    @article{Zakka_mjlab_A_Lightweight_2026,
+        author = {Zakka, Kevin and Liao, Qiayuan and Yi, Brent and Le Lay, Louis and Sreenath, Koushil and Abbeel, Pieter},
+        title = {{mjlab: A Lightweight Framework for GPU-Accelerated Robot Learning}},
+        url = {https://arxiv.org/abs/2601.22074},
+        year = {2026}
+    }
+
+Publications
+------------
+
+Papers that use mjlab. To add your work, open a pull request or post in
+`Show and Tell <https://github.com/mujocolab/mjlab/discussions/categories/show-and-tell>`_.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 60 30 10
+
+   * - Title
+     - Authors
+     - Year
+   * - `HUSKY: Humanoid Skateboarding System via Physics-Aware Whole-Body Control
+       <https://arxiv.org/abs/2602.03205>`_
+     - Han, Wang, Zhang, Liu, Luo, Bai, Li
+     - 2026
+   * - `DynaRetarget: Dynamically-Feasible Retargeting using Sampling-Based
+       Trajectory Optimization <https://arxiv.org/abs/2602.06827>`_
+     - Dhedin, Taouil, Omar, Yu, Tao, Dai, Khadiv
+     - 2026
+   * - `CLOT: Closed-Loop Global Motion Tracking for Whole-Body Humanoid
+       Teleoperation <https://arxiv.org/abs/2602.15060>`_
+     - Zhu, Cai, Yang, Ren, Xie, Wang, Wu, et al.
+     - 2026
+   * - `PAC-MAN: Perception-Aware CBF-RL for Whole-Body Safety in Humanoid
+       Dodgeball <https://arxiv.org/abs/2607.28623>`_
+       (`code <https://github.com/lzyang2000/perceptive_cbf_rl>`_)
+     - Yang, Li, Ames
+     - 2026
+
+Projects
+--------
+
+Projects built on mjlab. To add yours, open a pull request or post in
+`Show and Tell <https://github.com/mujocolab/mjlab/discussions/categories/show-and-tell>`_.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 35 65
+
+   * - Project
+     - Description
+   * - `menloresearch/asimov-mjlab <https://github.com/menloresearch/asimov-mjlab>`_
+     - Locomotion fork for the Asimov bipedal robot.
+   * - `Nagi-ovo/mjlab-homierl <https://github.com/Nagi-ovo/mjlab-homierl>`_
+     - H1 locomotion across multiple tasks with robustness to upper body disturbances.
+   * - `MyoHub/mjlab_myosuite <https://github.com/MyoHub/mjlab_myosuite>`_
+     - Musculoskeletal simulation integration with MyoSuite.
+   * - `MarcDcls/mjlab_upkie <https://github.com/MarcDcls/mjlab_upkie>`_
+     - Velocity control for the Upkie wheeled biped.
+   * - `unitreerobotics/unitree_rl_mjlab <https://github.com/unitreerobotics/unitree_rl_mjlab>`_
+     - Official Unitree RL environments for Go2, G1, and H1\_2.
+   * - `pal-robotics/pal_mjlab <https://github.com/pal-robotics/pal_mjlab>`_
+     - PAL Robotics robots and tasks.
+   * - `Msornerrrr/in-hand-rotation-mjlab <https://github.com/Msornerrrr/in-hand-rotation-mjlab>`_
+     - Sim to real RL for in hand cube rotation with the LEAP Hand.
+   * - `project-instinct/InstinctMJ <https://github.com/project-instinct/InstinctMJ>`_
+     - mjlab version of Project-Instinct, a whole-body control toolchain to study Instinct-Level intelligence.
+   * - `lzyang2000/twist2_mjlab <https://github.com/lzyang2000/twist2_mjlab>`_
+     - mjlab port of `TWIST2 <https://arxiv.org/abs/2511.02832>`_.
+   * - `wuji-technology/wuji-mjlab <https://github.com/wuji-technology/wuji-mjlab>`_
+     - In-hand cube reorientation on the Wuji Hand with sim-to-real deployment.
+   * - `wbc-mjlab/wbc-mjlab <https://github.com/wbc-mjlab/wbc-mjlab>`_
+     - Configurable whole-body control — shared MDP with task configs, one policy for many skills.
+   * - `pollen-robotics/microduck_rl <https://github.com/pollen-robotics/microduck_rl>`_
+     - Sim-to-real locomotion for `Microduck <https://pollen-robotics.com/microduck/>`_, an
+       open-source 25 cm bipedal robot from Pollen Robotics and Hugging Face.
diff --git a/docs/source/rewards.rst b/docs/source/rewards.rst
new file mode 100644
index 0000000..5dcb0e4
--- /dev/null
+++ b/docs/source/rewards.rst
@@ -0,0 +1,102 @@
+.. _rewards:
+
+Rewards
+=======
+
+Rewards are the training signal that shapes policy behavior. Each reward
+term is a function that returns a per-environment scalar every step. The
+reward manager computes a weighted sum of all terms and returns it to
+the training framework.
+
+Each term is registered by name with a ``RewardTermCfg`` that carries
+the callable and a ``weight``. Negative weights produce penalties.
+Additional keyword arguments are supplied through ``params``.
+
+.. code-block:: python
+
+    from mjlab.envs.mdp import rewards
+    from mjlab.managers.reward_manager import RewardTermCfg
+    from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+    rewards_cfg = {
+        "alive": RewardTermCfg(func=rewards.is_alive, weight=1.0),
+        "joint_torques": RewardTermCfg(
+            func=rewards.joint_torques_l2,
+            weight=-1e-4,
+            params={"asset_cfg": SceneEntityCfg("robot")},
+        ),
+    }
+
+
+Built-in reward functions
+-------------------------
+
+The functions below are available in ``mjlab.envs.mdp.rewards`` and are
+shared across tasks. Individual tasks also define their own reward
+functions tailored to the task objective (e.g. velocity tracking for
+locomotion). All reward functions return a tensor of shape
+``[num_envs]``.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 28 72
+
+   * - Function
+     - Description
+   * - ``is_alive``
+     - Returns ``1.0`` for environments that have not terminated this
+       step. Use with a positive weight as a survival bonus.
+   * - ``is_terminated``
+     - Returns ``1.0`` for environments that terminated due to a
+       non-timeout condition. Use with a negative weight to penalize
+       failure.
+   * - ``joint_torques_l2``
+     - Sum of squared actuator forces. Penalizes energy-intensive
+       actions.
+   * - ``joint_vel_l2``
+     - Sum of squared joint velocities.
+   * - ``joint_acc_l2``
+     - Sum of squared joint accelerations.
+   * - ``action_rate_l2``
+     - Sum of squared differences between the current and previous
+       action. Penalizes rapid changes in the policy output.
+   * - ``action_acc_l2``
+     - Sum of squared second-order action differences. Penalizes
+       high-frequency jitter in the action signal.
+   * - ``joint_pos_limits``
+     - Penalty for joint positions exceeding the soft limits. Zero
+       when all joints are within limits.
+   * - ``posture`` *(class)*
+     - Exponential kernel measuring deviation from the default joint
+       positions: ``exp(-mean(error^2 / std^2))``.
+   * - ``electrical_power_cost`` *(class)*
+     - Sum of positive mechanical power consumed by actuators.
+       Regenerative power is not penalized.
+   * - ``flat_orientation_l2``
+     - Sum of squares of the x and y components of the projected
+       gravity vector in the base frame. Zero when perfectly upright.
+
+
+Reward scaling by dt
+--------------------
+
+``ManagerBasedRlEnvCfg.scale_rewards_by_dt`` is ``True`` by default.
+When enabled, the reward manager multiplies each term by the environment
+step duration before accumulating it. This makes episodic reward totals
+invariant to simulation frequency: a task running at 50 Hz produces the
+same expected episode return as the same task at 200 Hz, because each
+step contributes proportionally less to the total.
+
+Per-term episodic sums are logged as ``Episode_Reward/<term_name>`` and
+are always divided by the episode duration, giving a reward rate that is
+comparable across runs with different episode lengths.
+
+
+Writing custom reward functions
+-------------------------------
+
+A reward function accepts ``env`` as its first argument and returns a
+``[num_envs]`` tensor. Additional parameters are declared as function
+arguments and supplied via ``RewardTermCfg(params={...})``. When a term
+needs to cache setup work or maintain per-episode state, implement it as
+a class. See :ref:`env-config-term-pattern` for the general pattern.
diff --git a/docs/source/scene.rst b/docs/source/scene.rst
new file mode 100644
index 0000000..db4236b
--- /dev/null
+++ b/docs/source/scene.rst
@@ -0,0 +1,175 @@
+.. _scene:
+
+Scene
+=====
+
+The scene merges entities, terrain, and sensors into a single
+simulation. ``SceneCfg`` describes the contents of the world, and the
+``Scene`` class handles MJCF composition, compilation, and runtime
+state management.
+
+.. code-block:: python
+
+    from mjlab.scene import SceneCfg
+    from mjlab.terrains import TerrainEntityCfg
+
+    # A robot on a flat ground plane with 4096 parallel environments.
+    scene_cfg = SceneCfg(
+        num_envs=4096,
+        env_spacing=2.5,
+        terrain=TerrainEntityCfg(terrain_type="plane"),
+        entities={"robot": robot_cfg},
+    )
+
+A scene with procedural terrain, sensors, and multiple entities:
+
+.. code-block:: python
+
+    from mjlab.scene import SceneCfg
+    from mjlab.terrains import TerrainEntityCfg
+    from mjlab.terrains.config import ROUGH_TERRAINS_CFG
+    from mjlab.sensor import RayCastSensorCfg, ContactSensorCfg
+
+    scene_cfg = SceneCfg(
+        num_envs=4096,
+        terrain=TerrainEntityCfg(
+            terrain_type="generator",
+            terrain_generator=ROUGH_TERRAINS_CFG,
+            max_init_terrain_level=5,
+        ),
+        entities={
+            "robot": robot_cfg,
+            "cube": cube_cfg,
+        },
+        sensors=(
+            RayCastSensorCfg(name="terrain_scan", ...),
+            ContactSensorCfg(name="feet_contact", ...),
+        ),
+    )
+
+
+Composition
+-----------
+
+The scene starts from a root ``MjSpec`` and
+`attaches <https://mujoco.readthedocs.io/en/stable/python.html#attachment>`_
+each entity's spec into it with a unique name prefix. A robot entity named ``"robot"`` has all its
+internal MuJoCo elements (bodies, joints, geoms, actuators, sensors)
+prefixed with ``robot/``, so ``base_link`` becomes ``robot/base_link``,
+``joint0`` becomes ``robot/joint0``, and so on. Prefixing prevents name
+collisions when multiple entities share element names and provides a
+consistent namespace for observation and reward terms.
+
+Terrain, when present, is attached without a prefix (its elements live
+in the global namespace). Sensors are added after entities and can
+reference entity elements by their prefixed names.
+
+``scene.compile()`` converts the composed ``MjSpec`` into a single
+``MjModel``. The ``Simulation`` class then uploads this model to the
+GPU via MuJoCo Warp. After the simulation is created,
+``scene.initialize()`` resolves each entity's element indices into the
+compiled model, allocates state buffers, and sets up GPU rendering
+resources for any camera or raycast sensors.
+
+``scene.to_zip(path)`` exports the compiled model as a ``.zip`` file
+for offline inspection in the standalone MuJoCo viewer. Each entity's
+initial state keyframe is merged into the export, so the model opens
+in its default pose.
+
+At runtime, entities and sensors are accessible by name:
+
+.. code-block:: python
+
+    robot = env.scene["robot"]              # Entity
+    scan = env.scene["terrain_scan"]        # Sensor
+    contact = env.scene["feet_contact"]     # Sensor
+
+    robot.data.joint_pos                    # [B, num_joints]
+    scan.data.distances                     # [B, N]
+    contact.data.force                      # [B, N, 3]
+
+Builtin sensors defined in an entity's XML are auto-discovered during
+composition and accessible with the entity name prefix:
+
+.. code-block:: python
+
+    imu = env.scene["robot/trunk_imu"]      # Auto-discovered sensor
+
+
+Environment origins
+-------------------
+
+Each environment in MuJoCo Warp is an independent world with its own
+state. Environments do not share physical space and cannot interact with
+each other. Environment origins exist for two purposes: spreading
+entities across the world for visualization (so the viewer shows robots
+side by side rather than stacked at the origin), and for locomotion
+tasks with procedural terrain, placing each environment at a specific
+sub-terrain patch.
+
+**Flat terrain.** Origins form a regular grid centered at the world
+origin with ``env_spacing`` meters between neighbors.
+
+**Procedural terrain.** The terrain generator produces a
+``num_rows x num_cols`` grid of sub-terrain patches, each with its own
+center point. Each environment is assigned to one patch, and the
+terrain curriculum system moves environments to harder patches as
+performance improves. See :ref:`terrain` for details.
+
+.. note::
+
+   All environments currently share the same ``MjModel`` (identical
+   meshes, geometries, and kinematic trees). Heterogeneous simulation,
+   where different worlds can have different meshes or geometries, is
+   `in progress in MuJoCo Warp <https://github.com/google-deepmind/mujoco_warp/pull/1009>`_.
+   mjlab will support this once it lands upstream.
+
+Reset event terms read ``scene.env_origins`` to position entities:
+
+.. code-block:: python
+
+    # Inside a reset event term.
+    robot.write_root_pose_to_sim(
+        default_root_pose + env_origins[env_ids]
+    )
+
+Each origin is marked with an invisible sphere site (geom group 4) that
+appears in the MuJoCo viewer when group 4 is enabled, useful for
+verifying placement during development.
+
+
+Custom spec editing
+-------------------
+
+Most scenes are fully described by their entities, terrain, and sensors.
+Occasionally a modification spans multiple entities. A tendon connecting
+a ceiling gantry to the robot, for example, cannot be defined inside
+either entity's MJCF because it references sites from both.
+
+The ``spec_fn`` callback on ``SceneCfg`` handles this case. It receives
+the fully composed ``MjSpec`` after all entities and sensors have been
+attached with their prefixed names, but before compilation:
+
+.. code-block:: python
+
+    import mujoco
+
+    def add_gantry(spec: mujoco.MjSpec):
+        spec.worldbody.add_site(name="gantry", pos=(0, 0, 2))
+        for side in ["left", "right"]:
+            tendon = spec.add_tendon(
+                name=f"{side}_rope",
+                limited=True,
+                range=(0, 1),
+            )
+            tendon.wrap_site("gantry")
+            tendon.wrap_site(f"robot/{side}_hook")
+
+    scene_cfg = SceneCfg(
+        entities={"robot": robot_cfg},
+        spec_fn=add_gantry,
+    )
+
+Other common uses include global equality constraints, custom
+visualization geometry, and any modification that requires access to the
+fully composed scene.
diff --git a/docs/source/sensors/index.rst b/docs/source/sensors/index.rst
new file mode 100644
index 0000000..7a5da45
--- /dev/null
+++ b/docs/source/sensors/index.rst
@@ -0,0 +1,455 @@
+.. _sensors:
+
+Sensors
+=======
+
+As described in :ref:`entity`, sensors sit between ``EntityData`` and
+raw simulation arrays in mjlab's data access hierarchy. At their
+simplest, they wrap MuJoCo sensor primitives with a clean interface
+that maps to real robot hardware. Beyond wrapping, they are a general
+abstraction for transforming simulation data into structured outputs:
+``ContactSensor`` aggregates contact pairs with reduction and air time
+tracking, ``RayCastSensor`` performs GPU-accelerated terrain scanning,
+``CameraSensor`` renders RGB and depth images on the GPU, and the base
+``Sensor`` class can be subclassed for custom measurement logic.
+
+Sensors are configured at the **scene level**, not on individual entities. A
+sensor can reference an entity element (a contact sensor on the robot's
+feet, an accelerometer attached to a body site), but it can also be
+independent of any entity entirely. This is why sensors live in
+``SceneCfg`` rather than ``EntityCfg``.
+
+.. code-block:: python
+
+    from mjlab.sensor import (
+        BuiltinSensorCfg, ContactSensorCfg, ContactMatch, ObjRef,
+    )
+
+    # A robot with an IMU accelerometer and foot contact detection.
+    scene_cfg = SceneCfg(
+        entities={"robot": robot_cfg},
+        sensors=(
+            BuiltinSensorCfg(
+                name="imu_acc",
+                sensor_type="accelerometer",
+                obj=ObjRef(type="site", name="imu_site", entity="robot"),
+            ),
+            ContactSensorCfg(
+                name="feet_contact",
+                primary=ContactMatch(
+                    mode="geom", pattern=r".*_foot$", entity="robot",
+                ),
+                secondary=ContactMatch(mode="body", pattern="terrain"),
+                fields=("found", "force"),
+            ),
+        ),
+    )
+
+    # Access at runtime.
+    imu = env.scene["robot/imu_acc"].data        # [B, 3] acceleration
+    feet = env.scene["feet_contact"].data         # ContactData
+    feet.found                                    # [B, P] contact count per foot
+    feet.force                                    # [B, P, 3] contact force per foot
+
+mjlab provides four sensor types: ``BuiltinSensor`` for native MuJoCo
+measurements, ``ContactSensor`` for structured contact detection,
+``RayCastSensor`` for GPU-accelerated raycasting, and ``CameraSensor``
+for RGB-D rendering. The base ``Sensor`` class can be subclassed for
+custom measurement logic; see `Extending: custom sensors`_ below.
+
+
+BuiltinSensor
+-------------
+
+``BuiltinSensor`` wraps MuJoCo's native sensor types. Each sensor is
+attached to a MuJoCo element (site, joint, body, etc.) via ``ObjRef``
+and returns a ``torch.Tensor`` with shape ``[num_envs, dim]`` where
+``dim`` depends on the sensor type (3 for vectors, 4 for quaternions,
+1 for scalars).
+
++-----------+----------------------------------------------------------------------------------------------------------------------------------------------------+
+| Category  | Available Sensors                                                                                                                                  |
++===========+====================================================================================================================================================+
+| **Site**  | ``accelerometer``, ``velocimeter``, ``gyro``, ``force``, ``torque``, ``magnetometer``, ``rangefinder``                                             |
++-----------+----------------------------------------------------------------------------------------------------------------------------------------------------+
+| **Joint** | ``jointpos``, ``jointvel``, ``jointlimitpos``, ``jointlimitvel``, ``jointlimitfrc``, ``jointactuatorfrc``                                          |
++-----------+----------------------------------------------------------------------------------------------------------------------------------------------------+
+| **Frame** | ``framepos``, ``framequat``, ``framexaxis``, ``frameyaxis``, ``framezaxis``, ``framelinvel``, ``frameangvel``, ``framelinacc``, ``frameangacc``    |
++-----------+----------------------------------------------------------------------------------------------------------------------------------------------------+
+| **Other** | ``actuatorpos``, ``actuatorvel``, ``actuatorfrc``, ``subtreecom``, ``subtreelinvel``, ``subtreeangmom``, ``clock``, ``e_potential``, ``e_kinetic`` |
++-----------+----------------------------------------------------------------------------------------------------------------------------------------------------+
+
+``ObjRef`` identifies which MuJoCo element the sensor attaches to. The
+``entity`` field scopes the lookup to a specific entity's namespace, and
+the sensor name is auto-prefixed accordingly (e.g., ``"imu_acc"`` on
+entity ``"robot"`` becomes ``"robot/imu_acc"``).
+
+.. code-block:: python
+
+    from mjlab.sensor import BuiltinSensorCfg, ObjRef
+
+    # Accelerometer attached to a site.
+    BuiltinSensorCfg(
+        name="imu_acc",
+        sensor_type="accelerometer",
+        obj=ObjRef(type="site", name="imu_site", entity="robot"),
+    )
+
+    # Joint limit sensor with output clamping.
+    BuiltinSensorCfg(
+        name="knee_limit",
+        sensor_type="jointlimitpos",
+        obj=ObjRef(type="joint", name="knee_joint", entity="robot"),
+        cutoff=0.1,
+    )
+
+    # Relative frame position (end-effector w.r.t. base).
+    BuiltinSensorCfg(
+        name="ee_pos",
+        sensor_type="framepos",
+        obj=ObjRef(type="body", name="end_effector", entity="robot"),
+        ref=ObjRef(type="body", name="base", entity="robot"),
+    )
+
+
+Auto-discovery
+^^^^^^^^^^^^^^
+
+Sensors already defined in an entity's XML are automatically discovered
+during scene composition and prefixed with the entity name. There is no
+need to create a ``BuiltinSensorCfg`` for these.
+
+.. code-block:: xml
+
+    <!-- In robot.xml -->
+    <sensor>
+        <accelerometer name="trunk_imu" site="imu_site"/>
+        <jointpos name="hip_sensor" joint="hip_joint"/>
+    </sensor>
+
+.. code-block:: python
+
+    # Access by prefixed name.
+    imu = env.scene["robot/trunk_imu"]
+    hip = env.scene["robot/hip_sensor"]
+
+
+ContactSensor
+-------------
+
+Each physics step, MuJoCo produces a flat, unstructured list of contact
+pairs across the entire scene. A single foot geom might generate several
+simultaneous contacts with the ground, interleaved with contacts from
+other entities. ``ContactSensor`` filters this raw list to the pairs you
+care about, reduces multiple contacts per element down to a fixed count,
+and packages the result into clean, batched tensors your policy can
+consume directly. It builds on MuJoCo's native
+`contact sensor <https://mujoco.readthedocs.io/en/stable/XMLreference.html#sensor-contact>`_.
+
+Primary and secondary
+^^^^^^^^^^^^^^^^^^^^^
+
+Contacts are pairwise: you typically want to know "did the robot's feet
+touch the terrain?", not just "did something touch something."
+``primary`` defines the elements you are measuring (the feet).
+``secondary`` optionally restricts what they are contacting (the
+terrain). When ``secondary`` is ``None``, any contact with a primary
+element counts.
+
+Each side is specified with a ``ContactMatch``. The ``mode`` selects the
+MuJoCo element type (``"geom"``, ``"body"``, or ``"subtree"``) and the
+``pattern`` accepts a regex or tuple of regexes matched against element
+names within the entity.
+
+.. code-block:: python
+
+    from mjlab.sensor import ContactSensorCfg, ContactMatch
+
+    # Foot geoms contacting the terrain body.
+    ContactSensorCfg(
+        name="feet_ground",
+        primary=ContactMatch(
+            mode="geom", pattern=r".*_foot$", entity="robot",
+        ),
+        secondary=ContactMatch(mode="body", pattern="terrain"),
+        fields=("found", "force"),
+    )
+
+    # Self-collision: pelvis subtree against itself.
+    ContactSensorCfg(
+        name="self_collision",
+        primary=ContactMatch(
+            mode="subtree", pattern="pelvis", entity="robot",
+        ),
+        secondary=ContactMatch(
+            mode="subtree", pattern="pelvis", entity="robot",
+        ),
+        fields=("found",),
+    )
+
+Output shape
+^^^^^^^^^^^^
+
+A pattern like ``r".*_foot$"`` resolves to ``P`` primary elements (e.g.
+four feet on a quadruped). Each primary becomes one column on the
+per-contact axis of the output tensors:
+
+.. list-table::
+   :header-rows: 1
+   :widths: 35 25 40
+
+   * - Field group
+     - Shape
+     - Notes
+   * - Per-contact
+       (``found``, ``force``, ``torque``, ``dist``, ``pos``, ``normal``,
+       ``tangent``)
+     - ``[B, P * num_slots, ...]``
+     - Primary-major: indices
+       ``[i * num_slots : (i + 1) * num_slots]`` belong to primary ``i``.
+   * - Per-primary
+       (``current_air_time``, ``last_air_time``,
+       ``current_contact_time``, ``last_contact_time``)
+     - ``[B, P]``
+     - Air-time fields are accumulated per primary, reducing across
+       slots (any slot in contact counts as the primary in contact).
+
+With the default ``num_slots=1`` the two shape families coincide
+(``N == P``), which is why most code can treat both as ``[B, P, ...]``.
+
+Use :attr:`mjlab.sensor.contact_sensor.ContactSensor.primary_names` to
+recover the index-to-name mapping after pattern expansion:
+
+.. code-block:: python
+
+    sensor = env.scene["feet_contact"]
+    sensor.primary_names                # ["FR_foot", "FL_foot", "RR_foot", "RL_foot"]
+    sensor.data.current_air_time[:, 0]  # air time for FR_foot
+
+Reduction
+^^^^^^^^^
+
+A single primary element can have many simultaneous contacts with the
+secondary (e.g. a flat foot resting on rough terrain has multiple
+contact points). The ``reduce`` mode collapses those raw contacts down
+to ``num_slots`` representative contacts:
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 80
+
+   * - Mode
+     - Behavior
+   * - ``"none"``
+     - Fast, non-deterministic selection of up to ``num_slots`` contacts.
+   * - ``"mindist"``
+     - Keep the deepest ``num_slots`` contacts.
+   * - ``"maxforce"``
+     - Keep the strongest ``num_slots`` contacts by force magnitude.
+   * - ``"netforce"``
+     - Sum all contacts into a single net wrench at the force-weighted
+       centroid. Always emits one slot per primary regardless of
+       ``num_slots``.
+
+When to set ``num_slots > 1``
+"""""""""""""""""""""""""""""
+
+Almost all configurations leave ``num_slots`` at its default of ``1``,
+because pattern expansion already produces one column per element of
+interest (one per foot, one per finger, one per body link). Increase
+``num_slots`` only when a single primary may have several physically
+distinct contact points that you want to inspect separately, for
+example:
+
+- Computing a center of pressure on a flat foot from its corner
+  contacts.
+- Reasoning about grasp quality from multiple fingertip-to-object
+  contact points.
+- Detecting tipping by watching whether one corner of a contact patch
+  loses contact.
+
+In those cases pair ``num_slots`` with ``reduce`` in
+``{"mindist", "maxforce", "none"}``. With ``reduce="netforce"`` it has
+no effect.
+
+.. note::
+
+   ``num_slots`` is a ceiling on what the sensor will store, not a
+   guarantee that MuJoCo will produce that many contacts. The collision
+   detector caps the number of contact points generated for each
+   geom-pair according to the geom types involved. For example a
+   sphere-vs-plane pair produces at most one contact, and a box-vs-box
+   pair produces at most four. Setting ``num_slots=8`` on a sphere
+   primary against a plane secondary therefore leaves seven slots
+   permanently zero. Check
+   `MuJoCo's collision documentation <https://mujoco.readthedocs.io/en/stable/computation/index.html#collision-detection>`_
+   for the per-pair limits.
+
+Fields
+^^^^^^
+
+The ``fields`` tuple selects which contact quantities to extract. Only
+requested fields are allocated; the rest are ``None`` on the output
+dataclass. Available fields are ``"found"``, ``"force"``,
+``"torque"``, ``"dist"``, ``"pos"``, ``"normal"``, and ``"tangent"``.
+
+.. note::
+
+   ``torque`` and the friction-tangent component of ``force`` are zero
+   unless the contact pair has friction enabled, which requires
+   ``condim >= 3`` on at least one geom in the pair. With ``condim=1``
+   (frictionless), the contact only produces a normal force. This is a
+   physics property of the contact, not a sensor limitation.
+
+Air time tracking
+^^^^^^^^^^^^^^^^^
+
+Locomotion tasks often need to know when feet land and take off for
+gait rewards. Setting ``track_air_time=True`` enables per-primary
+timing. The sensor maintains four additional tensors on
+``ContactData``, each shaped ``[B, P]``: ``current_air_time``,
+``last_air_time``, ``current_contact_time``, and
+``last_contact_time``. Two helper methods provide edge detection for
+transition events:
+
+.. code-block:: python
+
+    sensor = env.scene["feet_air"]
+    first_contact = sensor.compute_first_contact(dt)  # [B, P], True for primaries that just landed
+    first_air = sensor.compute_first_air(dt)           # [B, P], True for primaries that just took off
+
+Air time is per primary even when ``num_slots > 1``: the sensor reduces
+``found`` across slots so that any slot in contact counts as the
+primary being in contact.
+
+.. _contact-sensor-history:
+
+History (decimation safe contacts)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+When using decimation (multiple physics substeps per policy step), a
+brief collision can occur and resolve entirely within the substep loop.
+By the time the policy reads the sensor, the contact is gone and
+``found`` reports zero. Setting ``history_length`` on the sensor config
+tells the sensor to keep a rolling buffer of the last *N* substeps for
+force, torque, and distance fields. The policy can then inspect the
+full history and decide whether a real contact occurred.
+
+Set ``history_length`` equal to your decimation value so the buffer
+covers exactly one policy step:
+
+.. code-block:: python
+
+    ContactSensorCfg(
+        name="self_collision",
+        primary=ContactMatch(mode="subtree", pattern="pelvis", entity="robot"),
+        secondary=ContactMatch(mode="subtree", pattern="pelvis", entity="robot"),
+        fields=("found", "force"),
+        history_length=4,  # matches decimation=4
+    )
+
+The history tensors live on ``ContactData`` alongside the regular
+fields:
+
+.. code-block:: python
+
+    data = sensor.data
+    data.force_history   # [B, N, H, 3]  (H = history_length)
+    data.torque_history  # [B, N, H, 3]
+    data.dist_history    # [B, N, H]
+
+Index 0 is the most recent substep. To check whether any substep had
+a contact force above a threshold:
+
+.. code-block:: python
+
+    force_mag = torch.norm(data.force_history, dim=-1)  # [B, N, H]
+    had_contact = (force_mag > 10.0).any(dim=1).any(dim=-1)  # [B]
+
+.. note::
+
+   ``track_air_time=True`` already accumulates contact state across
+   substeps for gait rewards, so feet ground sensors typically do not
+   need ``history_length``. Use history for sensors where you need to
+   detect brief collisions that would otherwise be missed (self
+   collisions, illegal contact terminations).
+
+
+Output
+^^^^^^
+
+``ContactData`` is a dataclass whose fields correspond to the
+``fields`` tuple on the config. Unrequested fields are ``None``.
+
+.. code-block:: python
+
+    @dataclass
+    class ContactData:
+        found: Tensor | None     # [B, N] contact count
+        force: Tensor | None     # [B, N, 3]
+        torque: Tensor | None    # [B, N, 3]
+        dist: Tensor | None      # [B, N] penetration depth
+        pos: Tensor | None       # [B, N, 3] contact position
+        normal: Tensor | None    # [B, N, 3] surface normal
+        tangent: Tensor | None   # [B, N, 3]
+
+        # With track_air_time=True.
+        current_air_time: Tensor | None
+        last_air_time: Tensor | None
+        current_contact_time: Tensor | None
+        last_contact_time: Tensor | None
+
+
+RayCastSensor
+-------------
+
+``RayCastSensor`` provides GPU-accelerated raycasting for terrain
+scanning and depth sensing. It supports grid and pinhole camera ray
+patterns with configurable alignment modes. See :ref:`raycast_sensor`
+for full documentation.
+
+
+RGB-D Camera
+------------
+
+``CameraSensor`` renders RGB and depth images from MuJoCo cameras. See
+:ref:`rgbd_camera` for full documentation.
+
+
+Extending: custom sensors
+-------------------------
+
+All sensors inherit from ``Sensor[T]``, a generic base class where
+``T`` is the data type returned by the ``data`` property (e.g.,
+``torch.Tensor`` for ``BuiltinSensor``, ``ContactData`` for
+``ContactSensor``).
+
+The base class provides automatic per-step caching. The ``data``
+property calls ``_compute_data()`` on first access each step and
+caches the result. The cache is invalidated automatically when
+``update()`` or ``reset()`` is called, so multiple reads within the
+same step (from different observation or reward terms) pay the
+computation cost only once.
+
+**Lifecycle methods:**
+
+- ``edit_spec``: Add sensor elements to the MjSpec during scene
+  construction.
+- ``initialize``: Post-compilation setup. Cache sensor indices,
+  allocate buffers, resolve references.
+- ``update``: Called each physics step. Invalidates the data cache.
+  Override to maintain per-step state (e.g., air time counters).
+- ``reset``: Called on environment reset. Invalidates the data cache.
+  Override to clear per-environment state.
+- ``_compute_data``: Compute and return the sensor output. Called
+  lazily by the ``data`` property when the cache is stale.
+
+``ContactSensor`` and ``RayCastSensor`` are the most complete
+reference implementations for custom sensor development.
+
+.. toctree::
+   :maxdepth: 1
+   :hidden:
+
+   raycast_sensor
+   rgbd_camera
diff --git a/docs/source/sensors/raycast_sensor.rst b/docs/source/sensors/raycast_sensor.rst
new file mode 100644
index 0000000..38fa7f7
--- /dev/null
+++ b/docs/source/sensors/raycast_sensor.rst
@@ -0,0 +1,299 @@
+.. _raycast_sensor:
+
+RayCast Sensor
+==============
+
+``RayCastSensor`` provides GPU-accelerated raycasting for terrain
+scanning, obstacle detection, and depth sensing. Rays are emitted from
+a frame attached to a body, site, or geom in the scene, and the sensor
+reports hit distances, world-space hit positions, and surface normals.
+
+.. raw:: html
+
+   <video controls style="display: block; margin: 0 auto; max-width: 100%; height: auto;">
+     <source src="../../_static/raycast_demo.mp4" type="video/mp4">
+   </video>
+
+
+Quick start
+-----------
+
+.. code-block:: python
+
+    from mjlab.sensor import RayCastSensorCfg, GridPatternCfg, ObjRef
+
+    # Downward-facing grid for terrain height scanning.
+    raycast_cfg = RayCastSensorCfg(
+        name="terrain_scan",
+        frame=ObjRef(type="body", name="base", entity="robot"),
+        pattern=GridPatternCfg(size=(1.0, 1.0), resolution=0.1),
+        max_distance=5.0,
+    )
+
+    scene_cfg = SceneCfg(
+        entities={"robot": robot_cfg},
+        sensors=(raycast_cfg,),
+    )
+
+    # Access at runtime.
+    data = env.scene["terrain_scan"].data
+    data.distances      # [B, N] distance to hit, -1 if miss
+    data.hit_pos_w      # [B, N, 3] world-space hit positions
+    data.normals_w      # [B, N, 3] surface normals
+
+
+Ray patterns
+------------
+
+Ray patterns define the spatial distribution and direction of rays
+emitted from the sensor frame.
+
+.. grid:: 2
+
+   .. grid-item-card:: Grid pattern
+
+      Parallel rays in a 2D grid with fixed spatial resolution. The
+      ground footprint does not change with sensor height because ray
+      spacing is defined in world units (meters). The natural choice for
+      height maps and terrain scanning.
+
+      .. raw:: html
+
+         <video autoplay loop muted playsinline style="width: 100%; height: auto;">
+           <source src="../../_static/pattern_grid.mp4" type="video/mp4">
+         </video>
+
+   .. grid-item-card:: Pinhole camera pattern
+
+      Diverging rays emitted from a single origin, analogous to a depth
+      camera. The ground coverage increases with sensor
+      height because the field of view is fixed in angular units.
+
+      .. raw:: html
+
+         <video autoplay loop muted playsinline style="width: 100%; height: auto;">
+           <source src="../../_static/pattern_pinhole.mp4" type="video/mp4">
+         </video>
+
+.. code-block:: python
+
+    from mjlab.sensor import GridPatternCfg, PinholeCameraPatternCfg
+
+    # Parallel grid: fixed footprint, height-invariant.
+    grid = GridPatternCfg(
+        size=(1.0, 1.0),              # Grid dimensions in meters
+        resolution=0.1,               # Spacing between rays
+        direction=(0.0, 0.0, -1.0),   # Ray direction (down)
+    )
+
+    # Pinhole: perspective projection, diverging rays.
+    pinhole = PinholeCameraPatternCfg(
+        width=16,
+        height=12,
+        fovy=45.0,  # Vertical FOV in degrees
+    )
+
+    # Pinhole from a MuJoCo camera definition.
+    pinhole = PinholeCameraPatternCfg.from_mujoco_camera("robot/depth_cam")
+
+    # Pinhole from an intrinsic matrix.
+    pinhole = PinholeCameraPatternCfg.from_intrinsic_matrix(
+        intrinsic_matrix=[500, 0, 320, 0, 500, 240, 0, 0, 1],
+        width=640,
+        height=480,
+    )
+
+
+Pattern comparison
+^^^^^^^^^^^^^^^^^^
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 40 40
+
+   * - Aspect
+     - Grid
+     - Pinhole
+   * - Ray direction
+     - Parallel
+     - Diverging
+   * - Spacing unit
+     - Meters
+     - Degrees (FOV)
+   * - Height affects coverage
+     - No
+     - Yes
+   * - Projection model
+     - Orthographic
+     - Perspective
+
+
+Frame attachment
+----------------
+
+Rays are emitted from a frame in the scene specified via ``ObjRef``.
+The frame can be a body, site, or geom on any entity.
+
+.. code-block:: python
+
+    frame = ObjRef(type="body", name="base", entity="robot")
+    frame = ObjRef(type="site", name="scan_site", entity="robot")
+    frame = ObjRef(type="geom", name="sensor_mount", entity="robot")
+
+``exclude_parent_body`` (default ``True``) prevents rays from hitting
+the body to which the sensor is attached.
+
+
+Ray alignment
+-------------
+
+The ``ray_alignment`` setting controls how rays orient relative to the
+attached frame when the body rotates.
+
+.. raw:: html
+
+   <video autoplay loop muted playsinline
+          style="display: block; margin: 0 auto; max-width: 100%; height: auto;">
+     <source src="../../_static/ray_alignment_comparison.mp4" type="video/mp4">
+   </video>
+
+.. list-table::
+   :header-rows: 1
+   :widths: 15 45 40
+
+   * - Mode
+     - Description
+     - Use case
+   * - ``"base"``
+     - Full position and rotation tracking
+     - Body-mounted sensors
+   * - ``"yaw"``
+     - Follows yaw, ignores pitch and roll
+     - Terrain height maps
+   * - ``"world"``
+     - Fixed world-frame direction
+     - Gravity-aligned sensing
+
+.. code-block:: python
+
+    RayCastSensorCfg(
+        name="height_scan",
+        frame=ObjRef(type="body", name="base", entity="robot"),
+        pattern=GridPatternCfg(size=(1.0, 1.0), resolution=0.1),
+        ray_alignment="yaw",
+    )
+
+
+Geom group filtering
+--------------------
+
+MuJoCo assigns geoms to groups 0 through 5. Use
+``include_geom_groups`` to restrict which geoms rays can hit. This is
+useful for ignoring visual-only geoms or isolating terrain geometry.
+
+.. code-block:: python
+
+    RayCastSensorCfg(
+        name="terrain_only",
+        frame=ObjRef(type="body", name="base", entity="robot"),
+        pattern=GridPatternCfg(),
+        include_geom_groups=(0, 1),
+    )
+
+
+Output
+------
+
+``RayCastData`` is a dataclass with shape annotations relative to
+``B`` (number of environments) and ``N`` (number of rays).
+
+.. code-block:: python
+
+    @dataclass
+    class RayCastData:
+        distances: Tensor   # [B, N] distance to hit, -1 if miss
+        hit_pos_w: Tensor   # [B, N, 3] world-space hit positions
+        normals_w: Tensor   # [B, N, 3] surface normals
+        pos_w: Tensor       # [B, 3] sensor frame position
+        quat_w: Tensor      # [B, 4] sensor frame orientation (w, x, y, z)
+
+.. note::
+
+   Set ``debug_vis=True`` on the config to visualize ray hits at
+   runtime.
+
+
+Examples
+--------
+
+.. code-block:: python
+
+    from mjlab.sensor import (
+        RayCastSensorCfg, GridPatternCfg, PinholeCameraPatternCfg, ObjRef,
+    )
+
+    # Dense height map for terrain-aware locomotion.
+    height_scan = RayCastSensorCfg(
+        name="height_scan",
+        frame=ObjRef(type="body", name="base", entity="robot"),
+        pattern=GridPatternCfg(
+            size=(1.6, 1.0),
+            resolution=0.1,
+            direction=(0.0, 0.0, -1.0),
+        ),
+        ray_alignment="yaw",
+        max_distance=2.0,
+    )
+
+    # Simulated depth camera using pinhole projection.
+    depth_cam = RayCastSensorCfg(
+        name="depth",
+        frame=ObjRef(type="site", name="camera_site", entity="robot"),
+        pattern=PinholeCameraPatternCfg.from_mujoco_camera("robot/depth_cam"),
+        max_distance=10.0,
+    )
+
+    # Forward-facing obstacle scan.
+    obstacle_scan = RayCastSensorCfg(
+        name="obstacle",
+        frame=ObjRef(type="body", name="head", entity="robot"),
+        pattern=GridPatternCfg(
+            size=(0.5, 0.3),
+            resolution=0.1,
+            direction=(-1.0, 0.0, 0.0),
+        ),
+        max_distance=3.0,
+        include_geom_groups=(0,),
+    )
+
+
+TerrainHeightSensor
+-------------------
+
+``TerrainHeightSensor`` is a thin ``RayCastSensor`` subclass that adds
+per-frame vertical clearance to the sensor data. It computes
+``frame_z - hit_z`` for each ray, replaces misses with ``max_distance``,
+and reduces across rays per frame.
+
+.. code-block:: python
+
+    from mjlab.sensor import TerrainHeightSensorCfg, RingPatternCfg, ObjRef
+
+    cfg = TerrainHeightSensorCfg(
+        name="foot_height",
+        frame=(
+            ObjRef(type="site", name="left_foot", entity="robot"),
+            ObjRef(type="site", name="right_foot", entity="robot"),
+        ),
+        pattern=RingPatternCfg.single_ring(radius=0.04, num_samples=4),
+        max_distance=1.0,
+        include_geom_groups=(0,),
+    )
+
+    # At runtime:
+    sensor = env.scene["foot_height"]
+    sensor.data.heights    # [B, F] vertical clearance per foot
+    sensor.data.distances  # [B, N] raw ray distances (inherited)
+
+The ``reduction`` config field controls how rays are aggregated within
+each frame: ``"min"`` (default), ``"max"``, or ``"mean"``.
diff --git a/docs/source/sensors/rgbd_camera.rst b/docs/source/sensors/rgbd_camera.rst
new file mode 100644
index 0000000..cd7d8c8
--- /dev/null
+++ b/docs/source/sensors/rgbd_camera.rst
@@ -0,0 +1,219 @@
+.. _rgbd_camera:
+
+RGB-D Camera
+============
+
+``CameraSensor`` renders RGB and depth images on the GPU using MuJoCo
+Warp's ray-traced rendering pipeline. It can either wrap an existing
+MuJoCo camera defined in your XML or create a new one programmatically.
+
+
+Quick start
+-----------
+
+.. code-block:: python
+
+    from mjlab.sensor import CameraSensorCfg
+
+    # Wrap an existing MuJoCo camera from the robot's XML.
+    cam = CameraSensorCfg(
+        name="wrist_cam",
+        camera_name="robot/wrist_camera",
+        data_types=("rgb", "depth"),
+        width=160,
+        height=120,
+    )
+
+    scene_cfg = SceneCfg(
+        entities={"robot": robot_cfg},
+        sensors=(cam,),
+    )
+
+    # Access at runtime.
+    data = env.scene["wrist_cam"].data
+    data.rgb      # [B, 120, 160, 3] uint8
+    data.depth    # [B, 120, 160, 1] float32
+
+
+Creating vs wrapping cameras
+-----------------------------
+
+There are two ways to set up a camera sensor.
+
+**Wrap an existing camera.** If your MJCF model already defines a
+camera, pass its name via ``camera_name``. The sensor uses the
+camera's position, orientation, and field of view from the model.
+You can optionally override ``fovy`` or switch to orthographic
+projection.
+
+.. code-block:: python
+
+    # Wrap the camera named "front_cam" in the robot's XML.
+    CameraSensorCfg(
+        name="front",
+        camera_name="robot/front_cam",
+        data_types=("rgb",),
+    )
+
+**Create a new camera.** When ``camera_name`` is ``None`` (the
+default), the sensor adds a new camera to the MjSpec during scene
+construction. Specify ``pos``, ``quat``, and optionally ``fovy`` to
+place it.
+
+.. code-block:: python
+
+    # Fixed overhead camera on the worldbody.
+    CameraSensorCfg(
+        name="overhead",
+        pos=(0.0, 0.0, 2.0),
+        quat=(0.0, 0.707, 0.707, 0.0),
+        fovy=60.0,
+        width=320,
+        height=240,
+        data_types=("rgb", "depth"),
+    )
+
+
+Camera parameterization
+-----------------------
+
+MuJoCo supports two ways to define a camera's projection, and both
+work with ``CameraSensor``. See the `MuJoCo camera documentation
+<https://mujoco.readthedocs.io/en/stable/XMLreference.html#body-camera>`_
+for full details.
+
+**FOV-based.** The simpler approach. A single ``fovy`` (vertical field
+of view in degrees) combined with the image resolution defines the
+projection. This is the default when creating cameras
+programmatically via ``CameraSensorCfg``.
+
+**Intrinsic-based.** For matching real camera hardware, MuJoCo cameras
+can be parameterized with ``sensorsize``, ``focal`` (or
+``focalpixel``), and ``principal`` (or ``principalpixel``). These
+fields are set in the MJCF XML and provide direct control over the
+intrinsic matrix. When intrinsic parameters are present, ``fovy`` is
+ignored by MuJoCo.
+
+When wrapping an existing camera, the sensor inherits whichever
+parameterization the XML defines. When creating a new camera, the
+sensor uses ``fovy``. To use intrinsic parameters for a new camera,
+define it in your XML and wrap it with ``camera_name``.
+
+.. note::
+
+   If you plan to randomize the field of view with domain
+   randomization, use ``dr.cam_fovy`` for FOV-based cameras or
+   ``dr.cam_intrinsic`` for intrinsic-based cameras. Randomizing
+   ``cam_fovy`` has no effect on cameras that use intrinsic parameters.
+
+
+Body-mounted cameras
+--------------------
+
+Set ``parent_body`` to attach a new camera to a specific body rather
+than the worldbody. The ``pos`` and ``quat`` are then relative to the
+parent body frame, so the camera moves with the body.
+
+.. code-block:: python
+
+    # Camera mounted on the robot's end-effector.
+    CameraSensorCfg(
+        name="ee_cam",
+        parent_body="robot/link_6",
+        pos=(0.0, 0.0, 0.05),
+        quat=(1.0, 0.0, 0.0, 0.0),
+        fovy=45.0,
+        width=160,
+        height=120,
+        data_types=("rgb", "depth"),
+    )
+
+
+Data types
+----------
+
+The ``data_types`` tuple selects which image modalities to render.
+Only requested types are allocated; the other field on
+``CameraSensorData`` is ``None``.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 15 20 65
+
+   * - Type
+     - Shape
+     - Description
+   * - ``"rgb"``
+     - ``[B, H, W, 3]`` uint8
+     - Color image. Rendered as packed ABGR uint32 by MuJoCo Warp,
+       then unpacked to RGB channels on the GPU.
+   * - ``"depth"``
+     - ``[B, H, W, 1]`` float32
+     - Depth image. Values are distances from the camera plane.
+   * - ``"segmentation"``
+     - ``[B, H, W, 2]`` int32
+     - Typed segmentation. Channel 0 stores object IDs and channel 1 stores
+       MuJoCo object types. Background pixels are ``(-1, -1)``.
+
+
+Render settings
+---------------
+
+All camera sensors in a scene must share identical values for
+``use_textures``, ``use_shadows``, and ``enabled_geom_groups``. This
+is a constraint of the underlying MuJoCo Warp rendering system, which
+uses a single ``RenderContext`` for all cameras. Mismatched settings
+raise a ``ValueError`` at scene construction.
+
+.. code-block:: python
+
+    # These two cameras must agree on render settings.
+    cam_a = CameraSensorCfg(
+        name="cam_a",
+        camera_name="robot/front_cam",
+        use_textures=True,
+        use_shadows=False,
+        enabled_geom_groups=(0, 1, 2),
+        data_types=("rgb",),
+    )
+    cam_b = CameraSensorCfg(
+        name="cam_b",
+        camera_name="robot/wrist_cam",
+        use_textures=True,       # Must match cam_a
+        use_shadows=False,       # Must match cam_a
+        enabled_geom_groups=(0, 1, 2),  # Must match cam_a
+        data_types=("depth",),
+    )
+
+
+Output
+------
+
+``CameraSensorData`` is a dataclass with one field per data type.
+
+.. code-block:: python
+
+    @dataclass
+    class CameraSensorData:
+        rgb: Tensor | None      # [B, H, W, 3] uint8
+        depth: Tensor | None    # [B, H, W, 1] float32
+        segmentation: Tensor | None  # [B, H, W, 2] int32
+
+By default, the returned tensors are zero-copy views into the render
+buffer. Set ``clone_data=True`` on the config if you modify them in
+place, to avoid corrupting the shared buffer.
+
+
+Visualization in Viser
+----------------------
+
+The Viser viewer automatically discovers all ``CameraSensor`` instances
+in the scene and displays their RGB and depth outputs as live image
+panels in the GUI sidebar. A camera frustum is rendered in the 3D
+viewport showing the camera's position, orientation, and field of view.
+Depth images include an interactive scale slider for adjusting the
+visualization range.
+
+.. image:: ../_static/viser_camera_pane.png
+   :align: center
+   :alt: Viser viewer showing camera image panels and frustum visualization
diff --git a/docs/source/terminations.rst b/docs/source/terminations.rst
new file mode 100644
index 0000000..cb9f34c
--- /dev/null
+++ b/docs/source/terminations.rst
@@ -0,0 +1,70 @@
+.. _terminations:
+
+Terminations
+============
+
+Termination terms define when an episode ends. Each term is a function
+that returns a boolean per-environment tensor every step. The
+termination manager aggregates all terms and reports the result to the
+training framework as either a terminal failure or a truncation.
+
+Each term is registered by name with a ``TerminationTermCfg``. Setting
+``time_out=True`` marks the condition as a truncation rather than a
+terminal failure. Truncations map to the ``truncated`` signal in the
+Gym interface; failures map to ``terminated``. This distinction matters
+for value bootstrapping: the agent should estimate future value beyond
+a truncation but not beyond a failure.
+
+.. code-block:: python
+
+    from mjlab.envs.mdp import terminations
+    from mjlab.managers.termination_manager import TerminationTermCfg
+
+    terminations_cfg = {
+        "time_out": TerminationTermCfg(
+            func=terminations.time_out, time_out=True,
+        ),
+        "fallen": TerminationTermCfg(
+            func=terminations.bad_orientation,
+            params={"limit_angle": 1.0},
+        ),
+    }
+
+
+Built-in termination functions
+-------------------------------
+
+The functions below are available in ``mjlab.envs.mdp.terminations`` and
+are shared across tasks. Individual tasks may define additional
+termination functions specific to their objective. All termination
+functions return a boolean tensor of shape ``[num_envs]``.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 28 72
+
+   * - Function
+     - Description
+   * - ``time_out``
+     - Returns ``True`` when the episode length reaches
+       ``env.max_episode_length``. Register with ``time_out=True`` so
+       the manager treats it as a truncation.
+   * - ``bad_orientation``
+     - Returns ``True`` when the angle between the asset's up axis and
+       world up exceeds ``limit_angle`` (radians).
+   * - ``root_height_below_minimum``
+     - Returns ``True`` when the asset's root link height is below
+       ``minimum_height`` (meters).
+   * - ``nan_detection``
+     - Returns ``True`` when NaN or Inf values appear anywhere in the
+       physics state. A safety net to terminate diverged simulations
+       cleanly.
+
+
+Writing custom termination functions
+-------------------------------------
+
+Custom termination functions follow the same patterns as reward
+functions. A plain function accepts ``env`` and returns a boolean
+``[num_envs]`` tensor. See :ref:`env-config-term-pattern` for the
+general pattern.
diff --git a/docs/source/terrain.rst b/docs/source/terrain.rst
new file mode 100644
index 0000000..0e71851
--- /dev/null
+++ b/docs/source/terrain.rst
@@ -0,0 +1,382 @@
+.. _terrain:
+
+Terrain
+=======
+
+The terrain is the shared ground surface for all environments in a scene.
+mjlab supports two modes: a flat ground plane for tasks that do not need
+varying terrain, and a procedural terrain generator that assembles a grid
+of sub-terrain patches with configurable difficulty. Procedural terrain
+is particularly useful for training locomotion policies, where a
+curriculum of increasing ground difficulty drives robust walking and
+climbing behaviors.
+
+Terrain is configured through ``TerrainEntityCfg`` and passed to the
+scene via the ``terrain`` field of ``SceneCfg``. See :ref:`scene` for
+how the terrain integrates with the rest of the scene.
+
+
+Flat terrain
+------------
+
+The default mode. A single ground plane modeled as a MuJoCo plane geom
+with no procedural geometry. Environments are arranged in a regular grid
+with spacing controlled by ``env_spacing`` on ``SceneCfg``.
+
+.. code-block:: python
+
+    from mjlab.terrains import TerrainEntityCfg
+
+    terrain = TerrainEntityCfg(terrain_type="plane")
+
+
+Procedural terrain
+------------------
+
+For tasks that benefit from terrain variety (locomotion, navigation),
+``TerrainGeneratorCfg`` assembles a rectangular grid of sub-terrain
+patches. Each patch is generated from a ``SubTerrainCfg`` that defines
+the geometry and how it scales with difficulty.
+
+.. code-block:: python
+
+    from mjlab.terrains import TerrainEntityCfg
+    from mjlab.terrains.terrain_generator import TerrainGeneratorCfg
+    import mjlab.terrains as terrain_gen
+
+    terrain = TerrainEntityCfg(
+        terrain_type="generator",
+        terrain_generator=TerrainGeneratorCfg(
+            size=(8.0, 8.0),
+            num_rows=10,
+            border_width=20.0,
+            curriculum=True,
+            sub_terrains={
+                "flat": terrain_gen.BoxFlatTerrainCfg(proportion=0.2),
+                "stairs": terrain_gen.BoxPyramidStairsTerrainCfg(
+                    proportion=0.4,
+                    step_height_range=(0.0, 0.15),
+                    step_width=0.3,
+                    platform_width=2.0,
+                ),
+                "rough": terrain_gen.HfRandomUniformTerrainCfg(
+                    proportion=0.4,
+                    noise_range=(0.02, 0.10),
+                    noise_step=0.02,
+                ),
+            },
+        ),
+        max_init_terrain_level=5,
+    )
+
+The generator creates a grid of patches sized ``num_rows`` by either
+``num_cols`` (random mode) or ``len(sub_terrains)`` (curriculum mode,
+where ``num_cols`` is ignored). The ``sub_terrains`` dictionary maps
+names to ``SubTerrainCfg`` instances; each sub-terrain's ``proportion``
+controls robot spawning distribution across columns in curriculum mode,
+or per-patch sampling probability in random mode.
+
+
+Grid layout
+^^^^^^^^^^^
+
+Two generation modes control how terrain types are distributed across
+the grid:
+
+**Curriculum mode** (``curriculum=True``). Each terrain type gets exactly
+one column; the generator uses ``len(sub_terrains)`` columns regardless of
+``num_cols``. All patches in a column share the same terrain type, and
+difficulty increases from row 0 (easiest) to row ``num_rows - 1``
+(hardest). The ``proportion`` field controls how robots are distributed
+across columns at spawn time, not column count. This structured layout
+is what enables the curriculum system to advance environments to harder
+rows as performance improves.
+
+**Random mode** (``curriculum=False``). Every patch independently samples
+a terrain type weighted by ``proportion`` and a difficulty from
+``difficulty_range``. ``num_cols`` is honored. This provides maximum
+variety but no structured difficulty progression.
+
+
+The difficulty parameter
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Each sub-terrain's generation function receives a ``difficulty`` value
+that linearly interpolates the terrain's configurable ranges. For
+example, a ``BoxPyramidStairsTerrainCfg`` with
+``step_height_range=(0.0, 0.2)`` produces flat ground at difficulty 0
+and 20 cm steps at difficulty 1.
+
+In curriculum mode, difficulty is determined by the row:
+``difficulty = lower + (upper - lower) * row / max(num_rows - 1, 1)``,
+where ``(lower, upper) = difficulty_range``. Row 0 is exactly
+``lower``, row ``num_rows - 1`` is exactly ``upper``, and intermediate
+rows are evenly spaced between them. All columns in a given row share
+the same difficulty scalar; the visible variation across columns comes
+from each sub-terrain type generating different geometry at the same
+difficulty.
+
+.. note::
+
+   With ``num_rows=1`` and ``curriculum=True``, every patch is generated
+   at ``difficulty = lower`` (the easiest configured difficulty). Use
+   ``curriculum=False`` if you want a single grid of randomly sampled
+   difficulties instead.
+
+In random mode, difficulty is sampled uniformly from
+``difficulty_range`` independently for every patch.
+
+
+Sub-terrain types
+-----------------
+
+mjlab provides two families of sub-terrain types: **primitive terrains**
+built from box geoms, and **heightfield terrains** built from continuous
+elevation grids. All types inherit from ``SubTerrainCfg`` and accept a
+``proportion`` weight and optional ``flat_patch_sampling`` configuration.
+
+
+Primitive terrains
+^^^^^^^^^^^^^^^^^^
+
+Procedural patches built entirely from box geoms. The discrete geometry
+makes them well suited for staircases, stepping stones, and other
+structured obstacles. Most primitive types share common parameters:
+``platform_width`` (central flat area), ``border_width`` (flat margin),
+and one or more difficulty-scaled ranges.
+
+.. grid:: 3
+
+   .. grid-item-card:: Flat
+
+      .. image:: _static/terrains/box_flat.png
+
+      Flat box patch. Useful as an easy baseline in a curriculum grid.
+
+   .. grid-item-card:: Pyramid Stairs
+
+      .. image:: _static/terrains/box_pyramid_stairs.png
+
+      Pyramid staircase with steps descending inward toward a central
+      platform.
+
+   .. grid-item-card:: Inverted Pyramid Stairs
+
+      .. image:: _static/terrains/box_inverted_pyramid_stairs.png
+
+      Inverted pyramid with steps ascending from the outside inward.
+
+   .. grid-item-card:: Random Stairs
+
+      .. image:: _static/terrains/box_random_stairs.png
+
+      Pyramid staircase with random per-step heights.
+
+   .. grid-item-card:: Open Stairs
+
+      .. image:: _static/terrains/box_open_stairs.png
+
+      Concentric step rings. Can be a bowl or pyramid depending on the
+      ``inverted`` flag.
+
+   .. grid-item-card:: Random Grid
+
+      .. image:: _static/terrains/box_random_grid.png
+
+      Grid of boxes at randomly sampled heights.
+
+   .. grid-item-card:: Random Spread
+
+      .. image:: _static/terrains/box_random_spread.png
+
+      Randomly positioned and rotated boxes of varying sizes scattered
+      across the patch.
+
+   .. grid-item-card:: Stepping Stones
+
+      .. image:: _static/terrains/box_stepping_stones.png
+
+      Stepping-stone columns rising from a deep pit.
+
+   .. grid-item-card:: Narrow Beams
+
+      .. image:: _static/terrains/box_narrow_beams.png
+
+      Radial beams extending outward from a central platform above a
+      pit.
+
+   .. grid-item-card:: Tilted Grid
+
+      .. image:: _static/terrains/box_tilted_grid.png
+
+      Grid of independently tilted mesh tiles.
+
+   .. grid-item-card:: Nested Rings
+
+      .. image:: _static/terrains/box_nested_rings.png
+
+      Concentric ring structures at random heights.
+
+
+Heightfield terrains
+^^^^^^^^^^^^^^^^^^^^
+
+Continuous terrain profiles built from MuJoCo heightfield geoms. The
+surface is a dense grid of elevation samples, producing smooth slopes
+and undulating ground that box geoms cannot represent.
+
+.. grid:: 3
+
+   .. grid-item-card:: Pyramid Slope
+
+      .. image:: _static/terrains/hf_pyramid_slope.png
+
+      Smooth pyramid slope with a flat platform at the peak.
+      ``inverted=True`` places the platform at the bottom.
+
+   .. grid-item-card:: Random Uniform
+
+      .. image:: _static/terrains/hf_random_uniform.png
+
+      Random uniform noise, optionally downsampled and interpolated to
+      control feature size.
+
+   .. grid-item-card:: Wave
+
+      .. image:: _static/terrains/hf_wave.png
+
+      Sinusoidal wave profile.
+
+   .. grid-item-card:: Discrete Obstacles
+
+      .. image:: _static/terrains/hf_discrete_obstacles.png
+
+      Rectangular bumps and pits scattered across a flat base.
+
+   .. grid-item-card:: Perlin Noise
+
+      .. image:: _static/terrains/hf_perlin_noise.png
+
+      Fractal Perlin noise producing natural terrain undulation.
+
+
+Preset configurations
+---------------------
+
+mjlab ships three ready-made ``TerrainGeneratorCfg`` presets in
+``mjlab.terrains.config``:
+
+``ROUGH_TERRAINS_CFG``
+    A 10x20 random-mode grid with seven terrain types (flat, stairs,
+    inverted stairs, slopes, inverted slopes, random rough, waves).
+    Designed for locomotion training with a moderate difficulty range.
+    Set ``curriculum=True`` via ``dataclasses.replace`` to use it as a
+    curriculum grid (one column per terrain type).
+
+``STAIRS_TERRAINS_CFG``
+    A 10-row curriculum grid focused on stair traversal: flat plus
+    three pyramid-stair variants of increasing difficulty.
+
+``ALL_TERRAINS_CFG``
+    A 10-row random-mode grid covering all available terrain types at
+    equal proportion. Useful for training on maximum terrain variety.
+
+Both can be used directly or customized with ``dataclasses.replace()``:
+
+.. code-block:: python
+
+    from dataclasses import replace
+    from mjlab.terrains.config import ROUGH_TERRAINS_CFG
+
+    my_terrains = replace(ROUGH_TERRAINS_CFG, num_rows=5)
+
+
+Terrain curriculum
+------------------
+
+In curriculum mode the terrain grid provides a natural axis for
+progressive training: rows represent difficulty levels, and the
+curriculum system moves environments up or down the grid based on
+performance. See :ref:`curriculum` for full details on configuring
+curriculum terms.
+
+The key concepts:
+
+- Each environment tracks a ``terrain_level`` (row index) and
+  ``terrain_type`` (column index).
+- ``TerrainEntityCfg.max_init_terrain_level`` controls how high
+  environments can start at their first reset. Setting it to 5 means
+  environments begin on rows 0 through 5.
+- The built-in ``terrain_levels_vel`` curriculum term promotes
+  environments that track commanded velocity well and demotes
+  environments that fall or fail to make progress.
+- When an environment is promoted past the hardest row, it is randomly
+  reassigned to any row in ``[0, num_rows)`` to prevent the policy from
+  collapsing to a single difficulty level.
+
+
+Flat patch detection
+--------------------
+
+Heightfield terrains can pre-compute flat regions on their surface during
+generation. These flat patches are useful as safe spawn points for tasks
+that require the robot to start on level ground, even on otherwise rough
+terrain.
+
+Flat patch detection is configured per sub-terrain via the
+``flat_patch_sampling`` field on ``SubTerrainCfg``:
+
+.. code-block:: python
+
+    from mjlab.terrains.terrain_generator import FlatPatchSamplingCfg
+
+    rough = terrain_gen.HfRandomUniformTerrainCfg(
+        proportion=0.5,
+        noise_range=(0.02, 0.10),
+        flat_patch_sampling={
+            "spawn": FlatPatchSamplingCfg(
+                num_patches=10,
+                patch_radius=0.5,
+                max_height_diff=0.05,
+            ),
+        },
+    )
+
+The detection algorithm uses morphological filtering to find circular
+regions where height variation stays within ``max_height_diff``. Detected
+patches are accessible at runtime through
+``scene.terrain.flat_patches["spawn"]``.
+
+To spawn robots on detected patches instead of at the sub-terrain center,
+use ``reset_root_state_from_flat_patches`` as the reset event term. See
+:ref:`events` for details.
+
+.. note::
+
+   Only heightfield (``Hf*``) terrains support flat patch detection.
+   Primitive (``Box*``) terrains do not have heightfield data to analyze.
+   If any sub-terrain in the grid configures ``flat_patch_sampling``,
+   the flat patches array is allocated for all cells; sub-terrains
+   without patches have their slots filled with the sub-terrain's spawn
+   origin so that the reset event always receives valid positions.
+
+
+Debug visualization
+-------------------
+
+The terrain entity adds debug sites to three geom groups that can be
+toggled in the MuJoCo native viewer or Viser viewer:
+
+- **Group 3**: flat patch sites (yellow boxes marking safe spawn regions)
+- **Group 4**: environment origin sites (green spheres at each
+  environment's position)
+- **Group 5**: terrain origin sites (blue spheres at each sub-terrain
+  patch center)
+
+.. figure:: _static/terrains/flat_patch_group.png
+   :width: 100%
+   :align: center
+   :alt: Flat patch visualization
+
+   Flat patches (group 3) overlaid on a procedural terrain grid in the
+   Viser viewer.
diff --git a/docs/source/training/cloud.rst b/docs/source/training/cloud.rst
new file mode 100644
index 0000000..a493042
--- /dev/null
+++ b/docs/source/training/cloud.rst
@@ -0,0 +1,290 @@
+.. _cloud-training:
+
+Cloud Training
+==============
+
+This guide walks through launching training jobs on
+`Lambda Cloud <https://lambdalabs.com/>`_ using
+`SkyPilot <https://skypilot.readthedocs.io/>`_. SkyPilot provisions a GPU
+instance, syncs your code, runs the job, and tears down the machine when
+it finishes.
+
+Two SkyPilot task files live in ``scripts/cloud/``:
+
+.. list-table::
+   :widths: 30 70
+   :header-rows: 1
+
+   * - File
+     - Description
+   * - ``train.yaml``
+     - Installs mjlab directly with uv.
+   * - ``train-docker.yaml``
+     - Pulls the pre-built Docker image from GHCR for a reproducible
+       environment.
+
+
+Prerequisites
+-------------
+
+**1. Install SkyPilot**
+
+SkyPilot is a local CLI tool, not a project dependency. Install it with:
+
+.. code-block:: bash
+
+   uv tool install "skypilot[lambda]"
+
+**2. Lambda Cloud API key**
+
+Generate a key at `Lambda Cloud API keys
+<https://cloud.lambda.ai/api-keys/cloud-api>`_. Name it after your
+machine (e.g. ``kevins-macbook``) so you can tell keys apart later.
+
+.. code-block:: bash
+
+   mkdir -p ~/.lambda_cloud && chmod 700 ~/.lambda_cloud
+   echo "api_key = <your-api-key>" > ~/.lambda_cloud/lambda_keys
+   chmod 600 ~/.lambda_cloud/lambda_keys
+
+**3. Verify setup**
+
+.. code-block:: bash
+
+   sky check lambda
+
+You should see Lambda listed as an enabled cloud.
+
+**4. W&B credentials** *(optional)*
+
+If you log to Weights & Biases, install the ``wandb`` CLI and log in:
+
+.. code-block:: bash
+
+   uv tool install wandb
+   wandb login
+
+This stores your credentials in ``~/.netrc``. The SkyPilot task files
+mount this file onto the remote instance via ``file_mounts`` so that
+``wandb`` authenticates automatically, no environment variable needed.
+
+
+Quick start
+-----------
+
+From the repo root:
+
+.. code-block:: bash
+
+   sky launch scripts/cloud/train.yaml \
+     --env TASK=Mjlab-Velocity-Flat-Unitree-G1
+
+   # Or with Docker:
+   sky launch scripts/cloud/train-docker.yaml \
+     --env TASK=Mjlab-Velocity-Flat-Unitree-G1
+What happens behind the scenes:
+
+1. SkyPilot finds an available Lambda instance with the requested GPU.
+2. It provisions the instance and uploads your local code via rsync.
+3. The ``setup`` step runs (uv install or Docker pull).
+4. The ``run`` step runs (training).
+5. After 5 minutes of idle time the instance is terminated automatically.
+
+.. warning::
+
+   Lambda instances can only be **launched** or **terminated**. There is
+   no pause or suspend. Do not run ``sudo shutdown`` from inside the
+   instance; it will put the machine in an alert state and billing will
+   continue. Always use ``sky down`` to terminate.
+
+
+Common operations
+-----------------
+
+**List available GPUs**
+
+.. code-block:: bash
+
+   sky show-gpus --infra lambda
+
+**Choose a different GPU**
+
+.. code-block:: bash
+
+   sky launch scripts/cloud/train.yaml --gpus H100:1    # 1x H100
+   sky launch scripts/cloud/train.yaml --gpus A100:8    # 8x A100
+   sky launch scripts/cloud/train.yaml --gpus A10:1     # 1x A10 (cheaper)
+
+.. note::
+
+   Both task files pass ``--gpu-ids all``, so multi-GPU instances
+   automatically use :ref:`distributed training <distributed-training>`.
+   When requesting more than one GPU, consider scaling
+   ``MAX_ITERATIONS`` down proportionally. See
+   :ref:`distributed-training` for details on scaling behavior.
+
+**Override training parameters**
+
+Every variable in the YAML ``envs`` block can be overridden from the
+command line with ``--env``:
+
+.. code-block:: bash
+
+   sky launch scripts/cloud/train.yaml \
+     --env TASK=Mjlab-Velocity-Flat-Unitree-Go1 \
+     --env NUM_ENVS=8192 \
+     --env MAX_ITERATIONS=10000
+**Run your own task**
+
+.. code-block:: bash
+
+   sky launch scripts/cloud/train.yaml \
+     --env TASK=Mjlab-Velocity-Flat-Unitree-Go1
+
+To see all registered tasks:
+
+.. code-block:: bash
+
+   uv run list-envs
+   uv run list-envs --keyword Velocity  # filter by keyword
+
+
+Hyperparameter sweeps
+---------------------
+
+Use `W&B Sweeps <https://docs.wandb.ai/models/sweeps/>`_ with SkyPilot
+to search hyperparameters across a multi-GPU instance. The sweep
+controller lives on the W&B servers; each GPU on the instance runs an
+independent sweep agent that pulls a hyperparameter configuration,
+trains, and reports metrics.
+
+The example uses ``method: random``, where each agent samples
+independently. Bayesian search also works well with parallel agents.
+Agents report results back as they finish and the controller updates its
+model between rounds. If using Bayesian, set ``run_cap`` high enough for
+the optimizer to go through several rounds.
+
+Four files are involved:
+
+.. list-table::
+   :widths: 35 65
+   :header-rows: 1
+
+   * - File
+     - Description
+   * - ``sweep.yaml``
+     - W&B sweep configuration (parameters, search method, metric).
+   * - ``sweep-cluster.yaml``
+     - SkyPilot cluster definition (resources, setup, no run section).
+   * - ``sweep-agent.yaml``
+     - SkyPilot job definition that runs ``wandb agent`` on one GPU.
+   * - ``sweep-launch.sh``
+     - Convenience script that creates the sweep, provisions the
+       cluster, and submits one agent per GPU.
+
+**Quick start**
+
+.. code-block:: bash
+
+   ./scripts/cloud/sweep-launch.sh A100:8   # 8 agents on an 8xA100
+
+This creates a W&B sweep, provisions a cluster, and submits one agent
+per GPU. Each agent runs training with a different set of
+hyperparameters sampled by the sweep controller.
+
+**Manual steps** (if you prefer more control):
+
+.. code-block:: bash
+
+   # 1. Create the sweep (returns a SWEEP_ID).
+   wandb sweep scripts/cloud/sweep.yaml
+
+   # 2. Provision the cluster (runs setup, no agents yet).
+   sky launch scripts/cloud/sweep-cluster.yaml \
+     -c mjlab-sweep --gpus A100:8
+
+   # 3. Submit one agent per GPU.
+   sky exec mjlab-sweep scripts/cloud/sweep-agent.yaml \
+     --gpus A100:1 --env SWEEP_ID=<entity/project/sweep_id> -d
+
+Monitor progress on the W&B dashboard or with ``sky queue mjlab-sweep``.
+When done, tear down the cluster with ``sky down mjlab-sweep``.
+
+
+Monitoring
+----------
+
+Provisioning can take five minutes or more while Lambda allocates the
+instance. Open a second terminal to keep an eye on things:
+
+.. code-block:: bash
+
+   sky status                               # cluster state (INIT, UP, ...)
+   sky logs sky-<cluster-name>              # stream logs in real time
+   sky logs sky-<cluster-name> --no-follow  # print current logs and exit
+   sky queue sky-<cluster-name>             # job queue for the cluster
+
+.. tip::
+
+   If the cluster stays in ``INIT`` for a long time, the GPU type is
+   likely sold out. Cancel with ``sky down`` and try a different GPU, or
+   add ``--retry-until-up`` to let SkyPilot keep polling until capacity
+   opens up.
+
+.. code-block:: bash
+
+   sky down sky-<cluster-name>
+   sky launch scripts/cloud/train.yaml --retry-until-up
+
+
+Iterating on a failed job
+-------------------------
+
+When a job fails the cluster keeps running (and billing). You can fix
+the problem locally and resubmit without waiting for a new instance:
+
+.. code-block:: bash
+
+   sky exec sky-<cluster-name> scripts/cloud/train.yaml
+.. important::
+
+   ``sky exec`` rsyncs your latest code and reruns the ``run`` step
+   only. It does **not** rerun ``setup``. If your fix involves
+   dependency changes, use ``sky launch`` again or SSH in and run the
+   setup commands manually.
+
+Other useful commands:
+
+.. code-block:: bash
+
+   sky down sky-<cluster-name>  # terminate the instance immediately
+   ssh sky-<cluster-name>       # SSH in (SkyPilot configures this for you)
+
+
+Cost management
+---------------
+
+.. warning::
+
+   Always run ``sky status`` after each session to confirm nothing is
+   still running. Forgotten instances are the most common source of
+   unexpected charges. To terminate everything at once: ``sky down -a``.
+
+- Instances auto-terminate after 5 minutes of idle time by default.
+  You can change this in the YAML (``idle_minutes``) or at launch time
+  with ``--idle-minutes-to-autostop``.
+- The ``down: true`` setting in the YAML means the instance is fully
+  terminated when it stops, not just paused. Billing stops completely.
+
+
+Troubleshooting
+---------------
+
+**No instances available**
+
+Lambda GPUs sell out frequently. A few things to try:
+
+- Use ``--retry-until-up`` to poll automatically.
+- Try a different GPU type: ``--gpus A100:1``, ``--gpus A10:1``, etc.
+- If you have credentials for other clouds (GCP, AWS), SkyPilot can fall
+  back to them automatically.
diff --git a/docs/source/training/distributed_training.rst b/docs/source/training/distributed_training.rst
new file mode 100644
index 0000000..f3a2df6
--- /dev/null
+++ b/docs/source/training/distributed_training.rst
@@ -0,0 +1,109 @@
+.. _distributed-training:
+
+Distributed Training
+====================
+
+mjlab supports multi-GPU distributed training using
+`torchrunx <https://github.com/apoorvkh/torchrunx>`_. Each GPU runs
+independent rollouts with its own environments, and gradients are
+synchronized during policy updates. Throughput scales nearly linearly with
+GPU count.
+
+
+Usage
+-----
+
+.. code-block:: bash
+
+    # Single GPU (default).
+    uv run train <task-name> --gpu-ids "[0]"
+
+    # Two GPUs.
+    uv run train <task-name> --gpu-ids "[0, 1]"
+
+    # All available GPUs.
+    uv run train <task-name> --gpu-ids all
+
+    # CPU mode.
+    uv run train <task-name> --gpu-ids None
+
+Key points:
+
+- GPU indices are relative to ``CUDA_VISIBLE_DEVICES`` if set. For example,
+  ``CUDA_VISIBLE_DEVICES=2,3 uv run train ... --gpu-ids "[0, 1]"`` uses physical
+  GPUs 2 and 3.
+- Single-GPU and CPU modes run directly without torchrunx.
+
+
+Scaling behavior
+----------------
+
+Multi-GPU training is **data-parallel, not work-splitting**. Each GPU runs
+the full ``num-envs`` count independently, so the total experience collected
+per iteration is:
+
+.. code-block:: text
+
+    experience per iteration = num_envs x num_steps_per_env x num_gpus
+
+Iteration speed stays roughly the same because each GPU does the same amount
+of work. The benefit is that each policy update sees more diverse experience,
+so the policy converges faster in wall-clock time.
+
+.. important::
+
+   Because ``max-iterations`` is not automatically adjusted, training with
+   more GPUs runs for proportionally longer. If you want the same total
+   training time, scale ``max-iterations`` down by the number of GPUs
+   (e.g., halve it when doubling from 1 to 2 GPUs).
+
+
+How it works
+------------
+
+mjlab's role is to **isolate MuJoCo Warp simulations on each GPU** using
+``wp.ScopedDevice``. torchrunx handles the rest.
+
+**Process spawning.** ``torchrunx.Launcher`` spawns one process per GPU and
+sets ``RANK``, ``LOCAL_RANK``, and ``WORLD_SIZE`` to coordinate them. Each
+process executes the training function with its assigned GPU.
+
+**Independent rollouts.** Each process maintains its own:
+
+- Environment instances (with ``num-envs`` parallel environments), isolated
+  on its assigned GPU via ``wp.ScopedDevice``
+- Policy network copy
+- Experience buffer (sized ``num_steps_per_env * num_envs``)
+
+Each process uses ``seed = cfg.seed + local_rank`` to ensure different
+random experiences across GPUs, increasing sample diversity.
+
+**Gradient synchronization.** During the update phase, RSL-RL synchronizes
+gradients after each mini-batch through its ``reduce_parameters()`` method:
+
+1. Each process computes gradients independently on its local mini-batch
+2. All policy gradients are flattened into a single tensor
+3. ``torch.distributed.all_reduce`` averages gradients across all GPUs
+4. Averaged gradients are copied back to each parameter, keeping policies
+   synchronized
+
+**Single-writer I/O.** Only rank 0 writes config files, videos, and W&B
+logs to avoid race conditions.
+
+
+Logging
+-------
+
+By default, torchrunx process logs are saved to ``{log_dir}/torchrunx/``.
+This can be customized:
+
+.. code-block:: bash
+
+    # Disable torchrunx file logging.
+    uv run train <task-name> --gpu-ids "[0, 1]" --torchrunx-log-dir ""
+
+    # Custom log directory.
+    uv run train <task-name> --gpu-ids "[0, 1]" --torchrunx-log-dir /path/to/logs
+
+    # Environment variable (takes precedence over the flag).
+    TORCHRUNX_LOG_DIR=/tmp/logs uv run train <task-name> --gpu-ids "[0, 1]"
\ No newline at end of file
diff --git a/docs/source/training/motion_imitation.rst b/docs/source/training/motion_imitation.rst
new file mode 100644
index 0000000..5f6c0eb
--- /dev/null
+++ b/docs/source/training/motion_imitation.rst
@@ -0,0 +1,65 @@
+.. _motion-imitation:
+
+Motion Imitation
+================
+
+mjlab can train humanoid policies to imitate reference motions. This page
+covers motion data preprocessing and training.
+
+WandB registry setup
+--------------------
+
+mjlab uses `Weights & Biases <https://wandb.ai/>`_ to store and load
+reference motions. Before preprocessing any motions, create a WandB registry
+by following the
+`BeyondMimic instructions <https://github.com/HybridRobotics/whole_body_tracking/blob/main/README.md#motion-preprocessing--registry-setup>`_
+(only the registry creation step; skip the ``csv_to_npz.py`` command shown
+there).
+
+Motion preprocessing
+--------------------
+
+Reference motions are retargeted CSV files in Unitree's generalized
+coordinate convention (base position, base quaternion in xyzw, then joint
+angles).
+
+Convert a CSV to the NPZ format mjlab expects:
+
+.. code-block:: bash
+
+   MUJOCO_GL=egl uv run -m mjlab.scripts.csv_to_npz \
+       --input-file <PATH_TO_CSV> \
+       --output-name <MOTION_NAME> \
+       --input-fps 30 \
+       --output-fps 50 \
+       --render True
+
+The script plays the motion through MuJoCo Warp, computes forward kinematics
+for every body, and uploads the resulting NPZ to your WandB registry.
+
+.. warning::
+
+   You **must** use mjlab's converter (``mjlab.scripts.csv_to_npz``).
+   Converters from other frameworks such as IsaacLab produce NPZ files with
+   incompatible body orderings. The NPZ stores precomputed body positions and
+   quaternions indexed by body number, and different physics engines assign
+   body indices differently (MuJoCo uses depth first traversal, PhysX uses
+   breadth first). A mismatched NPZ will map tracking targets to the wrong
+   bodies and training will not converge.
+
+Training
+--------
+
+.. code-block:: bash
+
+   uv run train Mjlab-Tracking-Flat-Unitree-G1 \
+       --registry-name your-org/motions/motion-name \
+       --env.scene.num-envs 4096
+
+Evaluation
+----------
+
+.. code-block:: bash
+
+   uv run play Mjlab-Tracking-Flat-Unitree-G1 \
+       --wandb-run-path your-org/mjlab/run-id
diff --git a/docs/source/training/rsl_rl.rst b/docs/source/training/rsl_rl.rst
new file mode 100644
index 0000000..99cbab4
--- /dev/null
+++ b/docs/source/training/rsl_rl.rst
@@ -0,0 +1,277 @@
+.. _rsl_rl:
+
+Training with RSL-RL
+====================
+
+mjlab uses `RSL-RL <https://github.com/leggedrobotics/rsl_rl>`_ for on-policy
+reinforcement learning. The integration has three parts: a **task registry**
+that bundles environment and training configs under a single name, a
+**VecEnv wrapper** that adapts mjlab environments to the interface RSL-RL
+expects, and a set of **configuration dataclasses** that control the training
+run.
+
+
+Task registry
+-------------
+
+Every task in mjlab is a pair: an environment configuration
+(``ManagerBasedRlEnvCfg``) and a training configuration
+(``RslRlOnPolicyRunnerCfg``). The task registry maps a string name to this
+pair so that training can be launched by name from the CLI.
+
+Tasks are registered by calling ``register_mjlab_task`` in the task's
+``__init__.py``:
+
+.. code-block:: python
+
+    from mjlab.tasks.registry import register_mjlab_task
+    from mjlab.tasks.velocity.rl import VelocityOnPolicyRunner
+
+    from .env_cfgs import unitree_g1_rough_env_cfg, unitree_g1_flat_env_cfg
+    from .rl_cfg import unitree_g1_ppo_runner_cfg
+
+    register_mjlab_task(
+      task_id="Mjlab-Velocity-Rough-Unitree-G1",
+      env_cfg=unitree_g1_rough_env_cfg(),
+      play_env_cfg=unitree_g1_rough_env_cfg(play=True),
+      rl_cfg=unitree_g1_ppo_runner_cfg(),
+      runner_cls=VelocityOnPolicyRunner,
+    )
+
+Each registration takes:
+
+- ``task_id``: a unique name following the convention
+  ``Mjlab-{Category}-{Terrain}-{Robot}``
+- ``env_cfg``: the ``ManagerBasedRlEnvCfg`` used for training
+- ``play_env_cfg``: a variant with randomization disabled and episode length
+  set to infinity, used for evaluation
+- ``rl_cfg``: the ``RslRlOnPolicyRunnerCfg`` with PPO hyperparameters and
+  network architecture
+- ``runner_cls``: an optional custom runner class (defaults to
+  ``MjlabOnPolicyRunner``)
+
+All task packages under ``src/mjlab/tasks/`` are auto-discovered at import
+time, so adding a new task only requires creating the config package and
+calling ``register_mjlab_task``.
+
+
+Training and playback
+---------------------
+
+**Launching a training run:**
+
+.. code-block:: bash
+
+    uv run train Mjlab-Velocity-Flat-Unitree-G1 --num-envs 4096
+
+The task name is the first positional argument. The entire configuration
+hierarchy (environment, scene, rewards, PPO hyperparameters, etc.) is
+exposed as CLI flags through `tyro <https://brentyi.github.io/tyro/>`_.
+Every field in ``ManagerBasedRlEnvCfg`` and ``RslRlOnPolicyRunnerCfg`` can
+be overridden from the command line using dot-separated paths:
+
+.. code-block:: bash
+
+    uv run train Mjlab-Velocity-Flat-Unitree-G1 \
+        --num-envs 4096 \
+        --agent.max-iterations 10000 \
+        --agent.algorithm.learning-rate 3e-4 \
+        --env.decimation 2
+
+.. important::
+
+   - **Hyphens, not underscores**: Python field names use underscores
+     (``num_envs``), but CLI flags use POSIX-style hyphens (``--num-envs``).
+   - **Explicit booleans**: boolean flags require an explicit ``True`` or
+     ``False`` value (e.g., ``--agent.resume True``, not ``--agent.resume``).
+     This is intentional for compatibility with W&B sweep configs.
+
+To discover available flags, use ``--help`` and pipe through ``grep``:
+
+.. code-block:: bash
+
+    # See all flags.
+    uv run train Mjlab-Velocity-Flat-Unitree-G1 --help
+
+    # Search for a specific field.
+    uv run train Mjlab-Velocity-Flat-Unitree-G1 --help | grep learning-rate
+
+Some commonly used top-level flags:
+
+``--num-envs``
+    Number of parallel simulation environments.
+
+``--gpu-ids``
+    GPU indices to use. Pass multiple indices for multi-GPU training (see
+    :ref:`distributed-training`), or ``None`` for CPU mode.
+
+``--video``
+    Record training rollout videos to ``{log_dir}/videos/train/``.
+
+``--enable-nan-guard``
+    Enable NaN detection and state capture (see :ref:`nan-guard`).
+
+
+**Playing back a trained policy:**
+
+.. code-block:: bash
+
+    # From W&B.
+    uv run play Mjlab-Velocity-Flat-Unitree-G1 \
+        --wandb-run-path your-entity/mjlab/run-id
+
+    # From a local checkpoint.
+    uv run play Mjlab-Velocity-Flat-Unitree-G1 \
+        --checkpoint-file logs/rsl_rl/g1_velocity/2025-01-27_14-30-00/model_1000.pt
+
+Key ``play`` arguments:
+
+``--agent``
+    Policy mode: ``"trained"`` (default), ``"zero"`` (zero actions), or
+    ``"random"`` (uniform random).
+
+``--viewer``
+    Viewer backend: ``"native"`` (MuJoCo viewer) or ``"viser"``
+    (browser-based).
+
+``--no-terminations``
+    Disable termination conditions so the policy runs indefinitely.
+
+
+VecEnv wrapper
+--------------
+
+``RslRlVecEnvWrapper`` adapts a ``ManagerBasedRlEnv`` to RSL-RL's ``VecEnv``
+interface. It handles three things:
+
+1. **Observation format**: translates observation dictionaries into the
+   ``TensorDict`` format RSL-RL expects.
+2. **Done signal**: merges ``terminated`` and ``truncated`` into a single
+   ``dones`` tensor and passes ``time_outs`` through ``extras`` so RSL-RL can
+   bootstrap correctly on truncated episodes.
+3. **Action clipping**: applies optional action clipping when ``clip_actions``
+   is set in the runner config.
+
+The wrapper also calls ``env.reset()`` during construction because RSL-RL does
+not call reset before beginning rollout collection.
+
+In normal usage you do not interact with the wrapper directly. The training
+script handles wrapping automatically.
+
+
+Configuration
+-------------
+
+``RslRlOnPolicyRunnerCfg`` is the top-level training configuration. It groups
+runner settings, network architecture (``RslRlModelCfg``), and PPO
+hyperparameters (``RslRlPpoAlgorithmCfg``). The following example from the
+Unitree G1 velocity task shows a typical configuration:
+
+.. code-block:: python
+
+    from mjlab.rl import (
+        RslRlModelCfg,
+        RslRlOnPolicyRunnerCfg,
+        RslRlPpoAlgorithmCfg,
+    )
+
+    def unitree_g1_ppo_runner_cfg() -> RslRlOnPolicyRunnerCfg:
+        return RslRlOnPolicyRunnerCfg(
+            actor=RslRlModelCfg(
+                hidden_dims=(512, 256, 128),
+                activation="elu",
+                obs_normalization=True,
+            ),
+            critic=RslRlModelCfg(
+                hidden_dims=(512, 256, 128),
+                activation="elu",
+                obs_normalization=True,
+            ),
+            algorithm=RslRlPpoAlgorithmCfg(
+                value_loss_coef=1.0,
+                use_clipped_value_loss=True,
+                clip_param=0.2,
+                entropy_coef=0.01,
+                num_learning_epochs=5,
+                num_mini_batches=4,
+                learning_rate=1.0e-3,
+                schedule="adaptive",
+                gamma=0.99,
+                lam=0.95,
+                desired_kl=0.01,
+                max_grad_norm=1.0,
+            ),
+            experiment_name="g1_velocity",
+            save_interval=50,
+            num_steps_per_env=24,
+            max_iterations=30_000,
+        )
+
+All fields have sensible defaults and can be overridden from the command line
+(e.g., ``--agent.algorithm.learning-rate 3e-4``). Use ``--help`` to see the
+full list of available fields and their defaults.
+
+
+Checkpoints and logging
+-----------------------
+
+Training artifacts are written to:
+
+.. code-block:: text
+
+    logs/rsl_rl/{experiment_name}/{timestamp}/
+        model_{iteration}.pt      # policy checkpoints
+        params/
+            env.yaml              # full environment config
+            agent.yaml            # full runner config
+
+Checkpoints are saved every ``save_interval`` iterations and uploaded to W&B
+as model artifacts by default. Set ``upload_model=False`` in the runner
+config to disable uploads while keeping metric logging.
+
+.. rubric:: Resuming from a checkpoint
+
+.. code-block:: bash
+
+    uv run train Mjlab-Velocity-Flat-Unitree-G1 \
+        --num-envs 4096 \
+        --agent.resume True
+
+The runner searches for the most recent run directory under
+``logs/rsl_rl/{experiment_name}/`` and loads the highest-numbered checkpoint.
+Narrow the search with ``--agent.load-run`` (regex on directory names) and
+``--agent.load-checkpoint`` (regex on checkpoint filenames).
+
+``--agent.max-iterations`` controls how many *additional* iterations to run
+from the checkpoint. If you are resuming from iteration 11500 with
+``--agent.max-iterations 300`` (the default), training will run iterations
+11500 through 11800. Set this to the number of new iterations you want.
+
+To resume from a W&B run:
+
+.. code-block:: bash
+
+    uv run train Mjlab-Velocity-Flat-Unitree-G1 \
+        --num-envs 4096 \
+        --agent.resume True \
+        --wandb-run-path your-entity/mjlab/run-id
+
+
+Citation
+--------
+
+If you use RSL-RL in your research, consider citing:
+
+.. code-block:: bibtex
+
+    @article{schwarke2025rslrl,
+        title={RSL-RL: A Learning Library for Robotics Research},
+        author={Schwarke, Clemens and Mittal, Mayank and Rudin, Nikita and Hoeller, David and Hutter, Marco},
+        journal={arXiv preprint arXiv:2509.10771},
+        year={2025}
+    }
+
+.. toctree::
+   :maxdepth: 1
+
+   motion_imitation
diff --git a/docs/source/tutorials.rst b/docs/source/tutorials.rst
new file mode 100644
index 0000000..a624a5b
--- /dev/null
+++ b/docs/source/tutorials.rst
@@ -0,0 +1,11 @@
+.. _tutorials:
+
+Tutorials
+=========
+
+Tutorials to help you get started with mjlab.
+
+.. toctree::
+   :maxdepth: 1
+
+   tutorials/cartpole
diff --git a/docs/source/tutorials/cartpole.rst b/docs/source/tutorials/cartpole.rst
new file mode 100644
index 0000000..f3ce15c
--- /dev/null
+++ b/docs/source/tutorials/cartpole.rst
@@ -0,0 +1,439 @@
+.. _tutorial-cartpole:
+
+Cartpole: Building Your First Environment
+=========================================
+
+This tutorial walks through building a cartpole swingup task from scratch.
+A cart slides along a rail with a pole attached by a hinge. The agent
+applies force to the cart to swing the pole up and balance it.
+
+.. raw:: html
+
+   <video style="width:80%; display:block; margin:0 auto;" autoplay loop muted playsinline>
+     <source src="../../_static/tutorials/cartpole_swingup.mp4" type="video/mp4">
+   </video>
+   <p style="text-align:center; color:#666; font-size:0.9em; margin-top:0.5em;">
+     A trained agent performing the swingup task.
+   </p>
+
+The entire task lives in two files: an XML model and a Python module. We
+will build both piece by piece, then snap them together at the end.
+
+
+The XML model
+-------------
+
+Every environment starts with a MuJoCo XML that defines the physical
+system. For cartpole that means two bodies, two joints, and one motor:
+
+.. code-block:: xml
+
+    <!-- A cart on a rail with a pole attached by a hinge. -->
+    <body name="cart" pos="0 0 1">
+      <joint name="slider" type="slide" axis="1 0 0"
+             limited="true" range="-1.8 1.8" damping="5e-4"/>
+      <geom name="cart" type="box" size="0.2 0.15 0.1" mass="1"/>
+      <body name="pole_1" childclass="pole">
+        <joint name="hinge_1"/>
+        <geom name="pole_1"/>
+      </body>
+    </body>
+
+    <!-- A motor that pushes the cart along the rail. -->
+    <actuator>
+      <motor name="slide" joint="slider" gear="10"
+             ctrllimited="true" ctrlrange="-1 1"/>
+    </actuator>
+
+The motor has gear ratio 10 and control range [-1, 1], so the maximum
+force is 10 N. ``ctrllimited`` tells MuJoCo to clamp the control signal
+internally, so policy outputs outside this range are safe.
+
+The full XML is at ``src/mjlab/tasks/cartpole/cartpole.xml``.
+
+
+Building the environment
+------------------------
+
+Everything else lives in a single file, ``cartpole_env_cfg.py``. An
+mjlab environment is made of small, composable pieces. We will define
+each piece, then assemble them into a complete config at the end.
+
+Entity: wrapping the XML
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+An entity is a simulated object in the scene. It can be anything from a
+static table to an articulated robot. The ``EntityCfg`` wraps a MuJoCo
+XML and, optionally, actuator and initial state configurations. At
+runtime, the entity exposes simulation data (joint positions, velocities,
+etc.) as batched PyTorch tensors.
+
+The cartpole is an articulated entity with one actuator, so we need a
+function that loads the XML, an actuator configuration, and an initial
+state.
+
+.. code-block:: python
+
+    # Load the XML.
+    _CARTPOLE_XML = Path(__file__).parent / "cartpole.xml"
+
+    def _get_spec() -> mujoco.MjSpec:
+        return mujoco.MjSpec.from_file(str(_CARTPOLE_XML))
+
+    # Tell mjlab to use the motor defined in the XML as is.
+    _CARTPOLE_ARTICULATION = EntityArticulationInfoCfg(
+        actuators=(XmlActuatorCfg(target_names_expr=("slider",)),),
+    )
+
+The initial joint state depends on the task variant:
+
+.. tab-set::
+
+   .. tab-item:: Swingup
+
+      The pole starts pointing down (``hinge = pi``). The agent must swing
+      it up and balance it.
+
+      .. code-block:: python
+
+          _SWINGUP_INIT = EntityCfg.InitialStateCfg(
+              joint_pos={"slider": 0.0, "hinge_1": math.pi},
+              joint_vel={".*": 0.0},
+          )
+
+   .. tab-item:: Balance
+
+      The pole starts upright (``hinge = 0``). The agent only needs to
+      keep it balanced.
+
+      .. code-block:: python
+
+          _BALANCE_INIT = EntityCfg.InitialStateCfg(
+              joint_pos={"slider": 0.0, "hinge_1": 0.0},
+              joint_vel={".*": 0.0},
+          )
+
+Now we can snap these together into an ``EntityCfg``:
+
+.. code-block:: python
+
+    # Bundle the spec loader, actuator, and initial state into one config.
+    def _get_cartpole_cfg(swing_up: bool = False) -> EntityCfg:
+        return EntityCfg(
+            spec_fn=_get_spec,
+            articulation=_CARTPOLE_ARTICULATION,
+            init_state=_SWINGUP_INIT if swing_up else _BALANCE_INIT,
+        )
+
+That is the entity done. Later, we will pass it to the scene so the
+environment knows what to simulate.
+
+Observations: what the agent sees
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Each observation term is a function that reads from the simulation and
+returns a tensor. The observation manager concatenates them into a single
+vector for the policy. mjlab provides common terms in ``mjlab.envs.mdp``
+(joint positions, velocities, etc.), but you can always define your own.
+
+The cartpole has two moving parts, so its physical state is fully
+described by two positions and two velocities:
+
+.. list-table::
+   :header-rows: 1
+   :widths: 22 12 66
+
+   * - Term
+     - Dim
+     - Description
+   * - ``cart_pos``
+     - 1
+     - Where is the cart on the rail?
+   * - ``pole_angle``
+     - 2
+     - Which way is the pole pointing? (cosine and sine)
+   * - ``cart_vel``
+     - 1
+     - How fast is the cart moving?
+   * - ``pole_vel``
+     - 1
+     - How fast is the pole rotating?
+
+.. tip::
+
+   The pole angle is encoded as cosine and sine rather than a raw angle.
+   MuJoCo's unlimited hinge does not wrap the angle, so as the pole
+   spins the raw value keeps growing. Cosine and sine give the same
+   output for the same physical angle regardless of how many rotations
+   have occurred.
+
+This is the one custom observation function:
+
+.. code-block:: python
+
+    def pole_angle_cos_sin(env, asset_cfg) -> torch.Tensor:
+        asset: Entity = env.scene[asset_cfg.name]
+        angle = asset.data.joint_pos[:, asset_cfg.joint_ids]
+        return torch.cat([torch.cos(angle), torch.sin(angle)], dim=-1)
+
+.. note::
+
+   All data in mjlab is batched: tensors have shape
+   ``[num_envs, ...]`` because many environments run in parallel.
+   Every function you write should accept and return tensors with this
+   leading batch dimension.
+
+To wire these up, we create ``ObservationTermCfg`` entries and group
+them. ``SceneEntityCfg`` scopes each function to specific joints on
+the entity:
+
+.. code-block:: python
+
+    cart_cfg = SceneEntityCfg("cartpole", joint_names=("slider",))
+    hinge_cfg = SceneEntityCfg("cartpole", joint_names=("hinge_1",))
+
+    cart_pos = ObservationTermCfg(
+        func=joint_pos_rel, params={"asset_cfg": cart_cfg},
+    )
+    pole_angle = ObservationTermCfg(
+        func=pole_angle_cos_sin, params={"asset_cfg": hinge_cfg},
+    )
+    cart_vel = ObservationTermCfg(
+        func=joint_vel_rel, params={"asset_cfg": cart_cfg},
+    )
+    pole_vel = ObservationTermCfg(
+        func=joint_vel_rel, params={"asset_cfg": hinge_cfg},
+    )
+
+Each term pairs a function with the parameters to call it with. Now
+we group them. The RL algorithm expects an ``"actor"`` and ``"critic"``
+group; they share the same terms here, but when you add noise later
+you can give the critic clean observations
+(asymmetric actor-critic [#aac]_).
+
+.. code-block:: python
+
+    actor_terms = {
+        "cart_pos": cart_pos,
+        "pole_angle": pole_angle,
+        "cart_vel": cart_vel,
+        "pole_vel": pole_vel,
+    }
+
+    observations = {
+        "actor": ObservationGroupCfg(actor_terms),
+        "critic": ObservationGroupCfg({**actor_terms}),
+    }
+
+Actions: what the agent does
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The agent outputs a single scalar: the force on the cart.
+``JointEffortActionCfg`` writes the policy output to the actuator's
+effort target. The ``XmlActuator`` passes it to MuJoCo's ``ctrl``
+buffer, which clamps it to [-1, 1] and multiplies by the gear ratio:
+
+.. code-block:: python
+
+    actions = {
+        "effort": JointEffortActionCfg(
+            entity_name="cartpole",
+            actuator_names=("slider",),
+            scale=1.0,
+        ),
+    }
+
+Rewards: the training signal
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Each reward term is a function that returns a scalar per environment.
+The reward manager computes a weighted sum of all terms each step.
+
+The cartpole reward reproduces dm_control's smooth reward as a single
+multiplicative term:
+
+.. math::
+
+   r = \underbrace{\frac{\cos\theta + 1}{2}}_{\text{upright}}
+       \times \underbrace{\frac{1 + g(x)}{2}}_{\text{centered}}
+       \times \underbrace{\frac{4 + q(u)}{5}}_{\text{small control}}
+       \times \underbrace{\frac{1 + g(\dot\theta)}{2}}_{\text{small velocity}}
+
+Each factor is between 0 and 1. The product is high only when all four
+conditions hold simultaneously, preventing the agent from trading off
+one factor against another.
+
+.. code-block:: python
+
+    rewards = {
+        "smooth_reward": RewardTermCfg(
+            func=cartpole_smooth_reward,
+            weight=1.0,
+            params={"cart_cfg": cart_cfg, "hinge_cfg": hinge_cfg},
+        ),
+    }
+
+Terminations: when to stop
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The cartpole has no failure states, so the only termination is a time
+limit. Setting ``time_out=True`` tells the RL algorithm this is a
+truncation, not a true terminal state, so it bootstraps the value
+function past the episode boundary:
+
+.. code-block:: python
+
+    terminations = {
+        "time_out": TerminationTermCfg(func=time_out, time_out=True),
+    }
+
+Events: resetting the state
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+At the start of each episode, reset events randomize joint positions and
+velocities around the initial state we defined in the entity:
+
+.. code-block:: python
+
+    events = {
+        "reset_slider": EventTermCfg(
+            func=reset_joints_by_offset,
+            mode="reset",
+            params={
+                "position_range": (-0.1, 0.1),
+                "velocity_range": (-0.01, 0.01),
+                "asset_cfg": SceneEntityCfg("cartpole", joint_names=("slider",)),
+            },
+        ),
+        "reset_hinge": EventTermCfg(
+            func=reset_joints_by_offset,
+            mode="reset",
+            params={
+                "position_range": (-0.034, 0.034),
+                "velocity_range": (-0.01, 0.01),
+                "asset_cfg": SceneEntityCfg("cartpole", joint_names=("hinge_1",)),
+            },
+        ),
+    }
+
+The offsets are relative to the entity's initial state. For swingup the
+hinge starts at pi, so the noise keeps it near pointing down.
+
+Snapping everything together
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``ManagerBasedRlEnvCfg`` is where all the pieces come together. The
+scene holds the entity, and the config holds everything else:
+
+.. code-block:: python
+
+    return ManagerBasedRlEnvCfg(
+        scene=SceneCfg(
+            terrain=TerrainEntityCfg(terrain_type="plane"),
+            entities={"cartpole": _get_cartpole_cfg(swing_up=swing_up)},
+            num_envs=1,
+            env_spacing=4.0,
+        ),
+        observations=observations,
+        actions=actions,
+        events=events,
+        rewards=rewards,
+        terminations=terminations,
+        sim=SimulationCfg(
+            mujoco=MujocoCfg(timestep=0.01, disableflags=("contact",)),
+        ),
+        decimation=5,
+        episode_length_s=50.0,
+    )
+
+``decimation=5`` means the physics runs five substeps per policy step,
+giving a 20 Hz control frequency. ``disableflags=("contact",)`` skips
+contact computation since cartpole has no collisions. ``num_envs=1`` is
+the default; override it from the CLI with ``--num-envs``.
+
+
+Registration and training
+-------------------------
+
+The last step is to register the task so it can be launched by name.
+Each registration pairs an environment config with an RL config that
+specifies the network architecture and PPO hyperparameters. For cartpole
+a small network of two 64 unit hidden layers is plenty. The full RL
+config is in ``cartpole_env_cfg.py`` alongside the environment config.
+
+This goes in ``__init__.py``:
+
+.. code-block:: python
+
+    register_mjlab_task(
+        task_id="Mjlab-Cartpole-Swingup",
+        env_cfg=cartpole_swingup_env_cfg(),
+        play_env_cfg=cartpole_swingup_env_cfg(play=True),
+        rl_cfg=cartpole_ppo_runner_cfg(),
+    )
+
+Train:
+
+.. code-block:: bash
+
+    uv run train Mjlab-Cartpole-Swingup --env.scene.num-envs 4096
+
+Play back a trained checkpoint, either from a local file or a W&B run:
+
+.. code-block:: bash
+
+    uv run play Mjlab-Cartpole-Swingup --checkpoint-file logs/rsl_rl/cartpole/model_500.pt
+    uv run play Mjlab-Cartpole-Swingup --wandb-run-path <user/project/run_id>
+
+.. figure:: ../_static/tutorials/cartpole_training_curve.png
+   :width: 70%
+   :align: center
+   :alt: Cartpole swingup training curve
+
+   Mean reward over 5 seeds (shaded: one standard deviation).
+
+Config fields can be overridden from the CLI:
+
+.. code-block:: bash
+
+    uv run train Mjlab-Cartpole-Swingup \
+        --num-envs 8192 \
+        --agent.algorithm.learning-rate 3e-4 \
+        --agent.algorithm.entropy-coef 0.005
+
+
+Next steps
+----------
+
+**Add observation noise.** The current config has no noise, so the
+policy is brittle. Add noise to any observation term to train a more
+robust policy:
+
+.. code-block:: python
+
+    from mjlab.utils.noise import UniformNoiseCfg
+
+    ObservationTermCfg(
+        func=joint_pos_rel,
+        params={"asset_cfg": cart_cfg},
+        noise=UniformNoiseCfg(n_min=-0.05, n_max=0.05),
+    )
+
+**Randomize the physics.** Use the :ref:`domain_randomization` system
+to vary pole mass or joint damping across environments, training a
+policy that transfers across physical variations.
+
+**Explore other tasks.** The library ships with locomotion,
+manipulation, and motion tracking tasks you can run out of the box:
+``Mjlab-Velocity-Flat-Unitree-Go1``, ``Mjlab-Lift-Cube-Yam``, and
+``Mjlab-Tracking-Flat-Unitree-G1``, among others. Reading their source
+shows how more complex observation and reward structures are composed.
+
+**Build something new.** The cartpole is intentionally minimal. Once
+you are comfortable with the pieces, try designing your own robot model
+and task from scratch. The same pattern applies regardless of how
+complex the system becomes.
+
+.. rubric:: References
+
+.. [#aac] Pinto, L., Andrychowicz, M., Welinder, P., Zaremba, W., & Abbeel, P. (2018). `Asymmetric Actor Critic for Image-Based Robot Learning <https://www.roboticsproceedings.org/rss14/p08.pdf>`_. *Robotics: Science and Systems XIV*.
diff --git a/docs/source/viewers.rst b/docs/source/viewers.rst
new file mode 100644
index 0000000..e1c02c1
--- /dev/null
+++ b/docs/source/viewers.rst
@@ -0,0 +1,315 @@
+.. _viewers:
+
+Viewers
+=======
+
+mjlab ships two interactive viewers for evaluating trained policies and
+debugging environment behavior: a **native viewer** built on MuJoCo's
+`passive viewer <https://mujoco.readthedocs.io/en/stable/python.html#passive-viewer>`_
+that opens a desktop window, and a `Viser <https://viser.studio/main/>`_ **viewer** that runs in the
+browser. Both share a common ``ViewerConfig`` and execute the same
+simulation loop; they differ in interface, feature set, and where they
+shine.
+
+Launching a viewer
+------------------
+
+The ``play`` script accepts a ``--viewer`` flag:
+
+.. code-block:: bash
+
+    # Desktop window (MuJoCo native viewer).
+    uv run play Mjlab-Velocity-Flat-Unitree-G1 --viewer native \
+        --wandb-run-path your-entity/your-project/run_id
+
+    # Browser-based viewer (opens localhost:8080).
+    uv run play Mjlab-Velocity-Flat-Unitree-G1 --viewer viser \
+        --wandb-run-path your-entity/your-project/run_id
+
+The default is ``auto``, which selects native when a display server is
+available (``DISPLAY`` or ``WAYLAND_DISPLAY``) and falls back to Viser
+on headless machines.
+
+For quick exploration without a trained checkpoint, pass ``--agent zero``
+or ``--agent random`` to use a dummy policy:
+
+.. code-block:: bash
+
+    uv run play Mjlab-Velocity-Flat-Unitree-G1 --agent zero --viewer viser
+
+
+Viewer configuration
+--------------------
+
+Camera position, tracking target, and rendering options live in
+``ViewerConfig``, set through the ``viewer`` field of
+``ManagerBasedRlEnvCfg``:
+
+.. code-block:: python
+
+    from mjlab.viewer import ViewerConfig
+
+    viewer = ViewerConfig(
+        lookat=(0.0, 0.0, 0.5),
+        distance=3.0,
+        elevation=-20.0,
+        azimuth=135.0,
+    )
+
+The ``origin_type`` field controls the camera reference frame:
+
+.. list-table::
+   :header-rows: 1
+   :widths: 22 78
+
+   * - Origin type
+     - Behavior
+   * - ``WORLD``
+     - Free camera anchored at world origin (default).
+   * - ``ASSET_ROOT``
+     - Camera tracks the root body of the entity named by
+       ``entity_name``. Good for locomotion tasks where the robot moves
+       through the world.
+   * - ``ASSET_BODY``
+     - Camera tracks a specific body (``body_name``) within the entity
+       named by ``entity_name``. Useful for close-up views of an
+       end-effector or head.
+
+Example with asset tracking:
+
+.. code-block:: python
+
+    viewer = ViewerConfig(
+        origin_type=ViewerConfig.OriginType.ASSET_ROOT,
+        entity_name="robot",
+        distance=2.5,
+        elevation=-15.0,
+    )
+
+Additional fields:
+
+- ``enable_shadows`` and ``enable_reflections`` toggle rendering
+  quality.
+- ``height`` and ``width`` set the offscreen render resolution (used
+  by ``OffscreenRenderer`` and video recording).
+- ``env_idx`` selects which environment to display at startup.
+
+
+Native MuJoCo viewer
+---------------------
+
+.. figure:: _static/native_viewer.png
+   :width: 100%
+   :align: center
+   :alt: Native MuJoCo viewer with reward plots
+
+The native viewer opens MuJoCo's
+`passive viewer <https://mujoco.readthedocs.io/en/stable/python.html#passive-viewer>`_
+in a desktop window. It provides the fastest, most faithful rendering
+with full MuJoCo visual fidelity. Choose this viewer for local
+iteration and interactive perturbation testing. The
+MuJoCo team has a
+`video tutorial <https://www.youtube.com/watch?v=P83tKA1iz2Y>`_
+covering the viewer's built-in controls and navigation.
+
+**Keyboard controls.**
+
+.. list-table::
+   :header-rows: 1
+   :widths: 18 82
+
+   * - Key
+     - Action
+   * - ``Space``
+     - Pause or resume simulation.
+   * - ``Enter``
+     - Reset the environment.
+   * - ``+`` / ``-``
+     - Increase or decrease playback speed.
+   * - ``<`` / ``>``
+     - Cycle through environments (when ``num_envs > 1``).
+   * - ``A``
+     - Toggle rendering all environments simultaneously. Debug
+       visualization draws for all environments when this is active.
+   * - ``P``
+     - Toggle reward plots.
+   * - ``R``
+     - Toggle debug visualization.
+
+**Reward plots.**
+Press ``P`` to display per-term reward curves in a strip along the right
+edge of the window. Each term gets its own plot with an autoscaling
+y-axis. The plots update live and clear on environment reset. This is
+the fastest way to diagnose which reward terms dominate or misbehave
+during a rollout.
+
+**Interactive perturbations.**
+Click and drag any body in the scene to apply external forces during
+playback. The force transfers into the simulation on the next step,
+making it easy to test balance recovery, grasp robustness, or
+disturbance rejection without writing any code.
+
+Mouse perturbation forces are kept separate from programmatic forces
+(e.g. ``apply_body_impulse``) by routing them through different MuJoCo
+channels: programmatic forces use ``xfrc_applied`` (Cartesian body
+forces), while mouse forces are converted to ``qfrc_applied``
+(generalized joint forces) via ``mj_applyFT``. Both channels are summed
+during forward dynamics, so they coexist without conflict.
+
+**Domain randomization visualization.**
+The native viewer syncs all visual DR fields from GPU to CPU each
+frame. Randomized geom colors, sizes, positions, material colors,
+body poses, camera parameters, light positions, and inertia ellipsoids
+all render faithfully. If a DR event changes a visual property, the
+native viewer shows it.
+
+
+Viser (browser-based)
+---------------------
+
+.. figure:: _static/viser_viewer.png
+   :width: 100%
+   :align: center
+   :alt: Viser browser-based viewer
+
+The `Viser <https://viser.studio/main/>`_ viewer opens an interactive 3D scene
+in the browser at ``localhost:8080``. It works on remote machines over
+SSH tunnels, making it the natural choice for headless GPU servers and
+shared debugging sessions. Its web-based architecture makes it far more customizable than the
+native viewer. It also provides dedicated panels for camera sensor
+output that the native viewer does not.
+
+**Tab-based interface.**
+The sidebar organizes controls into tabs:
+
+- **Controls**: play/pause, reset, speed adjustment, environment
+  selection, and display settings (FOV, contacts, geom groups, camera
+  tracking).
+- **Rewards**: live per-term reward charts, toggled by a checkbox.
+- **Metrics**: live per-term metric charts when a ``MetricsManager``
+  is present.
+- **Camera Feeds**: live RGB and depth image panels for every
+  ``CameraSensor`` in the scene. A depth scale slider adjusts the
+  visualization range, and a frustum toggle draws the camera's field of
+  view in the 3D scene.
+- **Groups**: show or hide MuJoCo geom and site groups.
+
+**Camera sensor integration.**
+Viser auto-discovers all ``CameraSensor`` instances in the scene and
+displays their output as live image panels. Each camera also gets a
+frustum visualization in the 3D viewport, so you can see exactly what
+the sensor covers. This makes Viser the best tool for debugging camera
+placement, field of view, and depth sensing.
+
+**Contact visualization.**
+The Controls tab exposes contact rendering options. When enabled, contact
+points appear as colored markers and contact forces as red arrows,
+giving immediate visual feedback on collision behavior.
+
+.. note::
+
+   The Viser viewer does not support interactive perturbations (applying
+   wrenches to bodies). Use the native viewer for that, or set up
+   perturbations via :ref:`events <events>`.
+
+.. note::
+
+   Viser reads world-space body positions directly from GPU each frame,
+   so body poses update correctly. However, ``geom_rgba`` and
+   ``geom_size`` are baked into GLB meshes at scene construction time
+   and will not reflect per-world DR changes. This will be addressed in
+   a future release. For now, use the native viewer when you need to
+   verify visual DR.
+
+
+Debug visualization
+-------------------
+
+Both viewers support a shared ``DebugVisualizer`` interface that manager
+terms can draw into. Available primitives:
+
+- **Arrows**: velocity commands, force vectors, heading indicators.
+- **Spheres**: target positions, contact points.
+- **Cylinders**: limb targets, distance markers.
+- **Ellipsoids**: inertia visualization.
+- **Coordinate frames**: body frame orientation, end-effector targets.
+- **Ghost meshes**: transparent renderings of a robot at a target pose,
+  useful for motion tracking or goal visualization.
+
+In the native viewer, toggle debug visualization with ``R`` and press
+``A`` to show debug draws for all environments at once. In Viser, the
+Controls tab has toggles for both. The ``DebugVisualizer`` abstraction
+means that reward and command terms draw once, and both viewers display
+the result without any viewer-specific code.
+
+
+Offscreen renderer
+------------------
+
+For recording videos without a display, ``OffscreenRenderer`` renders
+frames using MuJoCo's offscreen rendering pipeline. It supports the
+same ``ViewerConfig`` camera configuration and accepts a debug
+visualization callback. The renderer is hard-capped at 32 environments
+to keep memory and rendering time manageable.
+
+The ``play`` script uses ``OffscreenRenderer`` when the ``--video`` flag
+is set:
+
+.. code-block:: bash
+
+    uv run play Mjlab-Velocity-Flat-Unitree-G1 --video --video-length 300 \
+        --wandb-run-path your-entity/your-project/run_id
+
+
+Quick comparison
+----------------
+
+.. list-table::
+   :header-rows: 1
+   :widths: 24 38 38
+
+   * -
+     - Native
+     - Viser
+   * - Interface
+     - Desktop window
+     - Browser (``localhost:8080``)
+   * - Best for
+     - Local iteration, perturbations
+     - Customization, remote dev, cameras
+   * - Reward plots
+     - ``P`` key, right-side strip
+     - Rewards tab, uPlot charts
+   * - Metrics plots
+     -
+     - Metrics tab
+   * - Camera feeds
+     -
+     - Auto-discovered, with frustum
+   * - Perturbations
+     - Click and drag
+     -
+   * - DR visualization
+     - Full (all visual fields synced)
+     - Partial (body poses only)
+   * - Contact rendering
+     -
+     - Contact points and forces
+   * - Multi-environment
+     - ``<`` ``>`` to cycle, ``A`` for all
+     - Dropdown selector
+
+
+Citation
+--------
+
+If you use the Viser viewer in your research, consider citing:
+
+.. code-block:: bibtex
+
+    @article{yi2025viser,
+        title={Viser: Imperative, web-based 3d visualization in python},
+        author={Yi, Brent and Kim, Chung Min and Kerr, Justin and Wu, Gina and Feng, Rebecca and Zhang, Anthony and Kulhanek, Jonas and Choi, Hongsuk and Ma, Yi and Tancik, Matthew and Kanazawa, Angjoo},
+        journal={arXiv preprint arXiv:2507.22885},
+        year={2025}
+    }
diff --git a/notebooks/create_new_task.ipynb b/notebooks/create_new_task.ipynb
new file mode 100644
index 0000000..efa1d29
--- /dev/null
+++ b/notebooks/create_new_task.ipynb
@@ -0,0 +1,775 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "view-in-github"
+   },
+   "source": [
+    "<a href=\"https://colab.research.google.com/github/mujocolab/mjlab/blob/main/notebooks/create_new_task.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "PO76KS1i-MwA"
+   },
+   "source": [
+    "# **🤖 CartPole Tutorial with mjlab**\n",
+    "\n",
+    "This notebook demonstrates how to create a custom reinforcement learning task using mjlab. We'll build a CartPole environment from scratch, including:\n",
+    "\n",
+    "1. **Robot Definition** - Define the CartPole model in MuJoCo XML\n",
+    "2. **Task Configuration** - Set up observations, actions, rewards, and terminations\n",
+    "3. **Training** - Train a policy using PPO\n",
+    "4. **Evaluation** - Visualize the simulation with the trained policy\n",
+    "\n",
+    "> **Note**: This tutorial demonstrates how to create a new task in mjlab. For more context, see the [official documentation](https://mujocolab.github.io/mjlab/)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "3ywZTgfR3C_w"
+   },
+   "source": [
+    "## **📦 Setup and Installation**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true,
+    "id": "dtLMJHzy3Nee"
+   },
+   "outputs": [],
+   "source": "# Clone the mjlab repository\n!if [ ! -d \"mjlab\" ]; then git clone -q https://github.com/mujocolab/mjlab.git; fi\n%cd /content/mjlab\n\n# Install mjlab in editable mode\n!pip install -e . -q\n\nprint(\"✓ Installation complete!\")"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "SSf2943z3b0s"
+   },
+   "source": [
+    "### **🔑 WandB Setup**\n",
+    "\n",
+    "Configure Weights & Biases for experiment tracking. Add your WandB API key to Colab Secrets:\n",
+    "- `WANDB_API_KEY`: from [wandb.ai/authorize](https://wandb.ai/authorize)\n",
+    "- `WANDB_ENTITY`: your wandb entity name"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "KC9ywCnm3dGg"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "from google.colab import userdata\n",
+    "\n",
+    "try:\n",
+    "  # Set this to use wandb logger\n",
+    "  os.environ[\"WANDB_API_KEY\"] = userdata.get(\"WANDB_API_KEY\")\n",
+    "  os.environ[\"WANDB_ENTITY\"] = userdata.get(\"WANDB_ENTITY\")\n",
+    "\n",
+    "  print(\"✓ WandB configured successfully!\")\n",
+    "except (AttributeError, KeyError):\n",
+    "  # Set this to disable wandb logger\n",
+    "  os.environ[\"WANDB_MODE\"] = \"disabled\"\n",
+    "\n",
+    "  print(\"⚠ WandB secrets not found. Training will proceed without WandB logging.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "mispfmy73lmq"
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## **🤖 Step 1: Define the Robot**\n",
+    "\n",
+    "We'll create a simple CartPole robot with:\n",
+    "- A sliding cart (1 DOF)\n",
+    "- A hinged pole (1 DOF)\n",
+    "- A velocity actuator to control the cart"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-FvJYPWD3scd"
+   },
+   "source": [
+    "### **📁 Structure Directories**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "OP-yET-R3ofN"
+   },
+   "outputs": [],
+   "source": [
+    "# Create the cartpole robot directory structure\n",
+    "!mkdir -p /content/mjlab/src/mjlab/asset_zoo/robots/cartpole/\n",
+    "!mkdir -p /content/mjlab/src/mjlab/asset_zoo/robots/cartpole/xmls\n",
+    "\n",
+    "print(\"✓ Directory structure created\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "MRyN1Pok3u25"
+   },
+   "source": [
+    "### **📝 Create MuJoCo XML Model**\n",
+    "\n",
+    "This XML defines the CartPole physics:\n",
+    "- **Ground plane** for visualization\n",
+    "- **Cart body** with a sliding joint (±2m range)\n",
+    "- **Pole body** with a hinge joint (±90° range)\n",
+    "- **Velocity actuator** for cart control"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "gWGyFX5V3yWc"
+   },
+   "outputs": [],
+   "source": [
+    "%%writefile /content/mjlab/src/mjlab/asset_zoo/robots/cartpole/xmls/cartpole.xml\n",
+    "<mujoco model=\"cartpole\">\n",
+    "  <compiler angle=\"degree\" coordinate=\"local\" inertiafromgeom=\"true\"/>\n",
+    "  <worldbody>\n",
+    "    <geom name=\"ground\" type=\"plane\" pos=\"0 0 0\" size=\"5 5 0.1\" rgba=\"0.8 0.9 0.8 1\"/>\n",
+    "    <body name=\"cart\" pos=\"0 0 0.1\">\n",
+    "      <geom type=\"box\" size=\"0.2 0.1 0.1\" rgba=\"0.2 0.2 0.8 1\" mass=\"1.0\"/>\n",
+    "      <joint name=\"slide\" type=\"slide\" axis=\"1 0 0\" limited=\"true\" range=\"-2 2\"/>\n",
+    "      <body name=\"pole\" pos=\"0 0 0.1\">\n",
+    "        <geom type=\"capsule\" size=\"0.05 0.5\" fromto=\"0 0 0 0 0 1\" rgba=\"0.8 0.2 0.2 1\" mass=\"2.0\"/>\n",
+    "        <joint name=\"hinge\" type=\"hinge\" axis=\"0 1 0\" range=\"-90 90\"/>\n",
+    "      </body>\n",
+    "    </body>\n",
+    "  </worldbody>\n",
+    "  <actuator>\n",
+    "    <velocity name=\"slide_velocity\" joint=\"slide\" ctrlrange=\"-20 20\" kv=\"20\"/>\n",
+    "  </actuator>\n",
+    "</mujoco>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "MpYCG9jI31dZ"
+   },
+   "source": [
+    "### **⚙️ Create Robot Configuration**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "HDhiyDTn4AVa"
+   },
+   "outputs": [],
+   "source": "%%writefile /content/mjlab/src/mjlab/asset_zoo/robots/cartpole/cartpole_constants.py\nfrom pathlib import Path\nimport mujoco\n\nfrom mjlab import MJLAB_SRC_PATH\nfrom mjlab.entity import Entity, EntityCfg, EntityArticulationInfoCfg\nfrom mjlab.actuator import XmlActuatorCfg\n\nCARTPOLE_XML: Path = (\n  MJLAB_SRC_PATH / \"asset_zoo\" / \"robots\" / \"cartpole\" / \"xmls\" / \"cartpole.xml\"\n)\nassert CARTPOLE_XML.exists(), f\"XML not found: {CARTPOLE_XML}\"\n\ndef get_spec() -> mujoco.MjSpec:\n  return mujoco.MjSpec.from_file(str(CARTPOLE_XML))\n\ndef get_cartpole_robot_cfg() -> EntityCfg:\n  \"\"\"Get a fresh CartPole robot configuration instance.\"\"\"\n  actuators = (\n    XmlActuatorCfg(\n      target_names_expr=(\"slide\",),\n    ),\n  )\n  articulation = EntityArticulationInfoCfg(actuators=actuators)\n  return EntityCfg(\n    spec_fn=get_spec,\n    articulation=articulation\n  )\n\n# if __name__ == \"__main__\":\n#   import mujoco.viewer as viewer\n#   robot = Entity(get_cartpole_robot_cfg())\n#   viewer.launch(robot.spec.compile())"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "-WSaDod04FwN"
+   },
+   "outputs": [],
+   "source": [
+    "# Create __init__.py for the cartpole robot package\n",
+    "%%writefile /content/mjlab/src/mjlab/asset_zoo/robots/cartpole/__init__.py\n",
+    "# Empty __init__.py to mark the directory as a Python package"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "W1tiBPfp_oVP"
+   },
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "\n",
+    "# Append src dir to python path\n",
+    "mjlab_src = \"/content/mjlab/src\"\n",
+    "if mjlab_src not in sys.path:\n",
+    "  sys.path.insert(0, mjlab_src)\n",
+    "  print(f\"✓ Added {mjlab_src} to Python path\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ToWF84qC4Hfg"
+   },
+   "source": [
+    "### **✅ Verify Robot Setup**\n",
+    "\n",
+    "Let's test that the robot can be loaded correctly."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "5tVsvqzQ4J9h"
+   },
+   "outputs": [],
+   "source": [
+    "from mjlab.asset_zoo.robots.cartpole.cartpole_constants import get_cartpole_robot_cfg\n",
+    "\n",
+    "from mjlab.entity import Entity\n",
+    "\n",
+    "# Load the robot\n",
+    "robot = Entity(get_cartpole_robot_cfg())\n",
+    "model = robot.spec.compile()\n",
+    "\n",
+    "# Display robot information\n",
+    "print(\"✓ CartPole robot loaded successfully!\")\n",
+    "print(f\"  • Degrees of Freedom (DOF): {model.nv}\")\n",
+    "print(f\"  • Number of Actuators: {model.nu}\")\n",
+    "print(f\"  • Bodies: {model.nbody}\")\n",
+    "print(f\"  • Joints: {model.njnt}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "e2_9dixlHON1"
+   },
+   "source": [
+    "### **📋 Register the Robot**\n",
+    "\n",
+    "Add the CartPole robot to the asset zoo registry."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "8qDIF__lHPcb"
+   },
+   "outputs": [],
+   "source": [
+    "# Add CartPole import to robots __init__.py\n",
+    "with open(\"/content/mjlab/src/mjlab/asset_zoo/robots/__init__.py\", \"a\") as f:\n",
+    "  f.write(\"\\n# CartPole robot\\n\")\n",
+    "  f.write(\"from mjlab.asset_zoo.robots.cartpole.cartpole_constants import \")\n",
+    "  f.write(\"get_cartpole_robot_cfg as get_cartpole_robot_cfg\\n\")\n",
+    "\n",
+    "print(\"✓ CartPole robot registered in asset zoo\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6lVD_L6PHWNm"
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## **🎯 Step 2: Define the Task (MDP)**\n",
+    "\n",
+    "Now we'll define the Markov Decision Process:\n",
+    "- **Observations**: pole angle, angular velocity, cart position, cart velocity\n",
+    "- **Actions**: cart velocity commands\n",
+    "- **Rewards**: upright reward + effort penalty\n",
+    "- **Terminations**: pole tips over or timeout\n",
+    "- **Events**: random pushes for robustness"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RQxe4TBrHb-I"
+   },
+   "source": [
+    "### **📁 Create Task Directory**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "nWBqdkziHc2G"
+   },
+   "outputs": [],
+   "source": [
+    "!mkdir -p /content/mjlab/src/mjlab/tasks/cartpole\n",
+    "\n",
+    "print(\"✓ Task directory created\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "GJfjPpm0Hhj1"
+   },
+   "source": [
+    "### **📝 Create Environment Configuration**\n",
+    "\n",
+    "This file contains the MDP (Markov Decision Process) components:\n",
+    "1. **Scene Config**: 64 parallel environments\n",
+    "2. **Actions**: Joint velocity control with 20.0 scale\n",
+    "3. **Observations**: Normalized state variables\n",
+    "4. **Rewards**: Upright reward (5.0) + effort penalty (-0.01)\n",
+    "5. **Events**: Joint resets + random pushes\n",
+    "6. **Terminations**: Pole tipped (>30°) or timeout (10s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "javx9XDIHkFI"
+   },
+   "outputs": [],
+   "source": [
+    "%%writefile /content/mjlab/src/mjlab/tasks/cartpole/env_cfg.py\n",
+    "\"\"\"CartPole task environment configuration.\"\"\"\n",
+    "\n",
+    "import math\n",
+    "import torch\n",
+    "\n",
+    "from mjlab.envs import ManagerBasedRlEnvCfg\n",
+    "from mjlab.envs.mdp.actions import JointVelocityActionCfg\n",
+    "from mjlab.managers.observation_manager import ObservationGroupCfg, ObservationTermCfg\n",
+    "from mjlab.managers.reward_manager import RewardTermCfg\n",
+    "from mjlab.managers.termination_manager import TerminationTermCfg\n",
+    "from mjlab.managers.event_manager import EventTermCfg\n",
+    "from mjlab.managers.scene_entity_config import SceneEntityCfg\n",
+    "from mjlab.scene import SceneCfg\n",
+    "from mjlab.sim import MujocoCfg, SimulationCfg\n",
+    "from mjlab.viewer import ViewerConfig\n",
+    "from mjlab.asset_zoo.robots.cartpole.cartpole_constants import get_cartpole_robot_cfg\n",
+    "from mjlab.envs import mdp\n",
+    "\n",
+    "\n",
+    "def cartpole_env_cfg(play: bool = False) -> ManagerBasedRlEnvCfg:\n",
+    "  \"\"\"Create CartPole environment configuration.\n",
+    "\n",
+    "  Args:\n",
+    "    play: If True, disables corruption and extends episode length for evaluation.\n",
+    "  \"\"\"\n",
+    "\n",
+    "  # ==============================================================================\n",
+    "  # Scene Configuration\n",
+    "  # ==============================================================================\n",
+    "\n",
+    "  scene_cfg = SceneCfg(\n",
+    "    num_envs=64 if not play else 16,  # Fewer envs for play mode\n",
+    "    extent=1.0,   # Spacing between environments\n",
+    "    entities={\"robot\": get_cartpole_robot_cfg()},\n",
+    "  )\n",
+    "\n",
+    "  viewer_cfg = ViewerConfig(\n",
+    "    origin_type=ViewerConfig.OriginType.ASSET_BODY,\n",
+    "    entity_name=\"robot\",\n",
+    "    body_name=\"pole\",\n",
+    "    distance=3.0,\n",
+    "    elevation=10.0,\n",
+    "    azimuth=90.0,\n",
+    "  )\n",
+    "\n",
+    "  sim_cfg = SimulationCfg(\n",
+    "    mujoco=MujocoCfg(\n",
+    "      timestep=0.02,  # 50 Hz control\n",
+    "      iterations=1,\n",
+    "    ),\n",
+    "  )\n",
+    "\n",
+    "  # ==============================================================================\n",
+    "  # Actions\n",
+    "  # ==============================================================================\n",
+    "\n",
+    "  actions = {\n",
+    "    \"joint_pos\": JointVelocityActionCfg(\n",
+    "      entity_name=\"robot\",\n",
+    "      actuator_names=(\".*\",),\n",
+    "      scale=20.0,\n",
+    "      use_default_offset=False,\n",
+    "    ),\n",
+    "  }\n",
+    "\n",
+    "  # ==============================================================================\n",
+    "  # Observations\n",
+    "  # ==============================================================================\n",
+    "\n",
+    "  actor_terms = {\n",
+    "    \"angle\": ObservationTermCfg(\n",
+    "      func=lambda env: env.sim.data.qpos[:, 1:2] / math.pi\n",
+    "    ),\n",
+    "    \"ang_vel\": ObservationTermCfg(\n",
+    "      func=lambda env: env.sim.data.qvel[:, 1:2] / 5.0\n",
+    "    ),\n",
+    "    \"cart_pos\": ObservationTermCfg(\n",
+    "      func=lambda env: env.sim.data.qpos[:, 0:1] / 2.0\n",
+    "    ),\n",
+    "    \"cart_vel\": ObservationTermCfg(\n",
+    "      func=lambda env: env.sim.data.qvel[:, 0:1] / 20.0\n",
+    "    ),\n",
+    "  }\n",
+    "\n",
+    "  observations = {\n",
+    "    \"actor\": ObservationGroupCfg(\n",
+    "      terms=actor_terms,\n",
+    "      concatenate_terms=True,\n",
+    "      enable_corruption=not play,  # Disable corruption in play mode\n",
+    "    ),\n",
+    "    \"critic\": ObservationGroupCfg(\n",
+    "      terms=actor_terms,  # Critic uses same observations\n",
+    "      concatenate_terms=True,\n",
+    "      enable_corruption=False,\n",
+    "    ),\n",
+    "  }\n",
+    "\n",
+    "  # ==============================================================================\n",
+    "  # Rewards\n",
+    "  # ==============================================================================\n",
+    "\n",
+    "  def compute_upright_reward(env):\n",
+    "    \"\"\"Reward for keeping pole upright (cosine of angle).\"\"\"\n",
+    "    return env.sim.data.qpos[:, 1].cos()\n",
+    "\n",
+    "  def compute_effort_penalty(env):\n",
+    "    \"\"\"Penalty for control effort.\"\"\"\n",
+    "    return -0.01 * (env.sim.data.ctrl[:, 0] ** 2)\n",
+    "\n",
+    "  rewards = {\n",
+    "    \"upright\": RewardTermCfg(func=compute_upright_reward, weight=5.0),\n",
+    "    \"effort\": RewardTermCfg(func=compute_effort_penalty, weight=1.0),\n",
+    "  }\n",
+    "\n",
+    "  # ==============================================================================\n",
+    "  # Events\n",
+    "  # ==============================================================================\n",
+    "\n",
+    "  def random_push_cart(env, env_ids, force_range=(-5, 5)):\n",
+    "    \"\"\"Apply random force to cart for robustness training.\"\"\"\n",
+    "    n = len(env_ids)\n",
+    "    random_forces = (\n",
+    "      torch.rand(n, device=env.device) *\n",
+    "      (force_range[1] - force_range[0]) +\n",
+    "      force_range[0]\n",
+    "    )\n",
+    "    env.sim.data.qfrc_applied[env_ids, 0] = random_forces\n",
+    "\n",
+    "  events = {\n",
+    "    \"reset_robot_joints\": EventTermCfg(\n",
+    "      func=mdp.reset_joints_by_offset,\n",
+    "      mode=\"reset\",\n",
+    "      params={\n",
+    "        \"asset_cfg\": SceneEntityCfg(\"robot\"),\n",
+    "        \"position_range\": (-0.1, 0.1),\n",
+    "        \"velocity_range\": (-0.1, 0.1),\n",
+    "      },\n",
+    "    ),\n",
+    "  }\n",
+    "\n",
+    "  # Add random pushes only in training mode\n",
+    "  if not play:\n",
+    "    events[\"random_push\"] = EventTermCfg(\n",
+    "      func=random_push_cart,\n",
+    "      mode=\"interval\",\n",
+    "      interval_range_s=(1.0, 2.0),\n",
+    "      params={\"force_range\": (-20.0, 20.0)},\n",
+    "    )\n",
+    "\n",
+    "  # ==============================================================================\n",
+    "  # Terminations\n",
+    "  # ==============================================================================\n",
+    "\n",
+    "  def check_pole_tipped(env):\n",
+    "    \"\"\"Check if pole has tipped beyond 30 degrees.\"\"\"\n",
+    "    return env.sim.data.qpos[:, 1].abs() > math.radians(30)\n",
+    "\n",
+    "  terminations = {\n",
+    "    \"timeout\": TerminationTermCfg(func=mdp.time_out, time_out=True),\n",
+    "    \"tipped\": TerminationTermCfg(func=check_pole_tipped, time_out=False),\n",
+    "  }\n",
+    "\n",
+    "  # ==============================================================================\n",
+    "  # Environment Configuration\n",
+    "  # ==============================================================================\n",
+    "\n",
+    "  return ManagerBasedRlEnvCfg(\n",
+    "    scene=scene_cfg,\n",
+    "    observations=observations,\n",
+    "    actions=actions,\n",
+    "    rewards=rewards,\n",
+    "    events=events,\n",
+    "    terminations=terminations,\n",
+    "    sim=sim_cfg,\n",
+    "    viewer=viewer_cfg,\n",
+    "    decimation=1,           # No action repeat\n",
+    "    episode_length_s=int(1e9) if play else 10.0,  # Infinite for play, 10s for training\n",
+    "  )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "fC5maMjzSj_X"
+   },
+   "source": [
+    "### **⚙️ Create RL Configuration**\n",
+    "\n",
+    "This file defines the PPO (Proximal Policy Optimization) training parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "C81zZm6mSj_X"
+   },
+   "outputs": [],
+   "source": "%%writefile /content/mjlab/src/mjlab/tasks/cartpole/rl_cfg.py\n\"\"\"RL configuration for CartPole task.\"\"\"\n\nfrom mjlab.rl.config import (\n  RslRlOnPolicyRunnerCfg,\n  RslRlModelCfg,\n  RslRlPpoAlgorithmCfg,\n)\n\n\ndef cartpole_ppo_runner_cfg() -> RslRlOnPolicyRunnerCfg:\n  \"\"\"Create RL runner configuration for CartPole task.\"\"\"\n  return RslRlOnPolicyRunnerCfg(\n    actor=RslRlModelCfg(\n      hidden_dims=(256, 128, 64),  # Smaller network for simpler task\n      activation=\"elu\",\n      obs_normalization=True,\n      distribution_cfg={\n        \"class_name\": \"GaussianDistribution\",\n        \"init_std\": 1.0,\n        \"std_type\": \"scalar\",\n      },\n    ),\n    critic=RslRlModelCfg(\n      hidden_dims=(256, 128, 64),\n      activation=\"elu\",\n      obs_normalization=True,\n    ),\n    algorithm=RslRlPpoAlgorithmCfg(\n      value_loss_coef=1.0,\n      use_clipped_value_loss=True,\n      clip_param=0.2,\n      entropy_coef=0.01,\n      num_learning_epochs=5,\n      num_mini_batches=4,\n      learning_rate=1.0e-3,\n      schedule=\"adaptive\",\n      gamma=0.99,\n      lam=0.95,\n      desired_kl=0.01,\n      max_grad_norm=1.0,\n    ),\n    experiment_name=\"cartpole\",\n    save_interval=50,\n    num_steps_per_env=24,\n    max_iterations=5_000,  # Fewer iterations for simpler task\n  )"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Oc8-AHGcHt78"
+   },
+   "source": [
+    "### **📋 Register the Task Environment**\n",
+    "\n",
+    "Register the CartPole task with mjlab registry."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "YitUGUBRHxD4"
+   },
+   "outputs": [],
+   "source": [
+    "%%writefile /content/mjlab/src/mjlab/tasks/cartpole/__init__.py\n",
+    "\"\"\"CartPole task registration.\"\"\"\n",
+    "\n",
+    "from mjlab.tasks.registry import register_mjlab_task\n",
+    "from mjlab.rl.runner import MjlabOnPolicyRunner\n",
+    "\n",
+    "from .env_cfg import cartpole_env_cfg\n",
+    "from .rl_cfg import cartpole_ppo_runner_cfg\n",
+    "\n",
+    "register_mjlab_task(\n",
+    "  task_id=\"Mjlab-Cartpole\",\n",
+    "  env_cfg=cartpole_env_cfg(),\n",
+    "  play_env_cfg=cartpole_env_cfg(play=True),\n",
+    "  rl_cfg=cartpole_ppo_runner_cfg(),\n",
+    "  runner_cls=MjlabOnPolicyRunner,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "K7wqLZR1rnGn"
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## **🚀 Step 3: Train the Agent**\n",
+    "\n",
+    "Now let's train a PPO policy to balance the CartPole!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Hht_hF4trqP2"
+   },
+   "outputs": [],
+   "source": [
+    "!python -m mjlab.scripts.train Mjlab-Cartpole --agent.max-iterations 201 --agent.save-interval 20"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "xCaqPznGrx8H"
+   },
+   "source": [
+    "### **📁 Locate Training Checkpoints**\n",
+    "\n",
+    "After training, checkpoints are saved locally."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "uPnmHYu8r0uY"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import re\n",
+    "from pathlib import Path\n",
+    "\n",
+    "# Find the most recent training run\n",
+    "log_dir = Path(\"/content/mjlab/logs/rsl_rl/cartpole\")\n",
+    "if log_dir.exists():\n",
+    "  runs = sorted(log_dir.glob(\"*\"), key=os.path.getmtime, reverse=True)\n",
+    "  if runs:\n",
+    "    latest_run = runs[0]\n",
+    "    print(f\"✓ Latest training run: {latest_run.name}\\n\")\n",
+    "\n",
+    "    # List checkpoints - sorted by iteration number\n",
+    "    checkpoints = list(latest_run.glob(\"model_*.pt\"))\n",
+    "    if checkpoints:\n",
+    "      # Extract iteration number and sort numerically\n",
+    "      def get_iteration(ckpt):\n",
+    "        match = re.search(r\"model_(\\d+)\\.pt\", ckpt.name)\n",
+    "        return int(match.group(1)) if match else 0\n",
+    "\n",
+    "      checkpoints = sorted(checkpoints, key=get_iteration)\n",
+    "\n",
+    "      print(f\"Found {len(checkpoints)} checkpoints:\")\n",
+    "      for ckpt in checkpoints[-5:]:  # Show last 5\n",
+    "        size_mb = ckpt.stat().st_size / (1024 * 1024)\n",
+    "        iteration = get_iteration(ckpt)\n",
+    "        print(f\"  • {ckpt.name} (iteration {iteration}, {size_mb:.2f} MB)\")\n",
+    "\n",
+    "      # Store the last checkpoint path\n",
+    "      last_checkpoint = str(checkpoints[-1])\n",
+    "      print(f\"\\n💾 Last checkpoint: {last_checkpoint}\")\n",
+    "    else:\n",
+    "      print(\"⚠ No checkpoints found yet\")\n",
+    "  else:\n",
+    "    print(\"⚠ No training runs found\")\n",
+    "else:\n",
+    "  print(\"⚠ Log directory not found. Have you run training yet?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "eWFS9Pw7r2uH"
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## **🎮 Step 4: Visualize the Trained Policy**\n",
+    "\n",
+    "Let's see the trained policy in action!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "78PgHtpfr5sb"
+   },
+   "source": [
+    "### **🌐 Launch Viser API**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "_9tGiFyBr2bW"
+   },
+   "outputs": [],
+   "source": [
+    "import subprocess\n",
+    "import sys\n",
+    "\n",
+    "process = subprocess.Popen(\n",
+    "  [\n",
+    "    \"python\",\n",
+    "    \"-m\",\n",
+    "    \"mjlab.scripts.play\",\n",
+    "    \"Mjlab-Cartpole\",\n",
+    "    \"--checkpoint_file\",\n",
+    "    last_checkpoint,\n",
+    "    \"--num_envs\",\n",
+    "    \"4\",\n",
+    "  ],\n",
+    "  stdout=subprocess.PIPE,\n",
+    "  stderr=subprocess.STDOUT,\n",
+    "  universal_newlines=True,\n",
+    "  bufsize=1,\n",
+    ")\n",
+    "\n",
+    "detected_port = None\n",
+    "\n",
+    "for line in process.stdout:\n",
+    "  print(line, end=\"\")\n",
+    "  sys.stdout.flush()\n",
+    "\n",
+    "  # Extract port number from viser output\n",
+    "  port_match = re.search(r\":(\\d{4})\", line)\n",
+    "  if port_match and \"viser\" in line.lower():\n",
+    "    detected_port = int(port_match.group(1))\n",
+    "    print(\"\\n\" + \"=\" * 34)\n",
+    "    print(f\"✅ Server is running on port {detected_port}!\")\n",
+    "    print(\"=\" * 34)\n",
+    "    break"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XgzJXyBXssZS"
+   },
+   "source": [
+    "### **🖥️ Embed Client as iframe**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ll89QnuSuUxx"
+   },
+   "outputs": [],
+   "source": [
+    "from google.colab import output\n",
+    "\n",
+    "port = detected_port if detected_port else 8081\n",
+    "output.serve_kernel_port_as_iframe(port=port, height=700)"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "include_colab_link": true,
+   "provenance": [],
+   "toc_visible": true
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/notebooks/demo.ipynb b/notebooks/demo.ipynb
new file mode 100644
index 0000000..ca6bcc0
--- /dev/null
+++ b/notebooks/demo.ipynb
@@ -0,0 +1,99 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Use W&B offline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!wandb offline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## **Or** login using an API from your W&B account"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!wandb login"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Now you are set to run the demo!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "AqSj5JwRz_Lw",
+    "outputId": "4c299831-6279-430e-ca8e-f2a58e8f4720"
+   },
+   "outputs": [],
+   "source": "import subprocess\nimport sys\n\nprocess = subprocess.Popen(\n  [\n    \"uvx\",\n    \"--refresh\",\n    \"--from\",\n    \"mjlab==1.2.0\",\n    \"demo\",\n  ],\n  stdout=subprocess.PIPE,\n  stderr=subprocess.STDOUT,\n  universal_newlines=True,\n  bufsize=1,\n)\n\nfor line in process.stdout:\n  print(line, end=\"\")\n  sys.stdout.flush()\n\n  if \"serving\" in line.lower() or \"running on\" in line.lower() or \"8081\" in line:\n    print(\"\\n\" + \"=\" * 50)\n    print(\"✅ Server is running! Execute the next cell to view.\")\n    print(\"=\" * 50)\n    break"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 421
+    },
+    "id": "i7xycbkt1MFB",
+    "outputId": "7fae85cc-1678-4f59-f700-688fbdc6fb84"
+   },
+   "outputs": [],
+   "source": [
+    "from google.colab import output\n",
+    "\n",
+    "output.serve_kernel_port_as_iframe(8081)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "1IhDzu_i1uQt"
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..9972f9f
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,172 @@
+[build-system]
+requires = ["uv_build>=0.12.1,<0.13.0"]
+build-backend = "uv_build"
+
+[project]
+name = "mjlab"
+version = "1.6.0"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+readme = { file = "README.md", content-type = "text/markdown" }
+authors = [
+  {name = "The MjLab Developers"},
+]
+keywords = ["mujoco", "mujoco-warp", "simulation", "reinforcement-learning", "robotics"]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
+  "Intended Audience :: Science/Research",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3 :: Only",
+  "Typing :: Typed",
+  "Environment :: GPU :: NVIDIA CUDA",
+  "Topic :: Scientific/Engineering",
+  "Natural Language :: English",
+]
+description = "Isaac Lab API, powered by MuJoCo-Warp, for RL and robotics research."
+requires-python = ">=3.10,<3.14"
+dependencies = [
+  "prettytable",
+  "tqdm",
+  "tyro>=1.0.1",
+  "torch>=2.7.0",
+  "torchrunx>=0.3.4",
+  "warp-lang>=1.14.0",
+  "mujoco-warp~=3.11.0",
+  "mujoco~=3.11.0",
+  "trimesh>=4.8.3",
+  "scipy>=1.15",
+  "viser>=1.0.27",
+  "mjviser>=0.0.14",
+  "mediapy>=1.2.7",
+  "numpy",
+  "imageio-ffmpeg",
+  "tensordict",
+  "rsl-rl-lib==5.5.0",
+  "tensorboard>=2.20.0",
+  "onnxscript>=0.5.4",
+  "wandb>=0.22.3",
+]
+
+[project.urls]
+  "Bug Reports" = "https://github.com/mujocolab/mjlab/issues"
+  "Source" = "https://github.com/mujocolab/mjlab"
+
+[project.scripts]
+train = "mjlab.scripts.train:main"
+play = "mjlab.scripts.play:main"
+demo = "mjlab.scripts.demo:main"
+list-envs = "mjlab.scripts.list_envs:main"
+viz-nan = "mjlab.scripts.nan_viz:main"
+export-scene = "mjlab.scripts.export_scene:main"
+
+[dependency-groups]
+dev = [
+  "ipdb>=0.13.13",
+  "pre-commit>=4.3.0",
+  "pyright>=1.1.408",
+  "onnxruntime>=1.19.0; python_version >= '3.11'",
+  "pytest>=v9.0.3",
+  "ruff>=0.16.1",
+  "ty>=v0.0.14",
+]
+docs = [
+  "myst-parser>=4.0.1",
+  "sphinx>=8.1.3",
+  "sphinx-autodoc-typehints>=3.0.1",
+  "sphinx-autobuild>=2024.10.3",
+  "sphinx-book-theme>=1.1.4",
+  "sphinx-copybutton>=0.5.2",
+  "sphinx-design>=0.6.1",
+  "autodocsumm",
+  "sphinxemoji",
+  "sphinxcontrib.bibtex",
+  "sphinx-icon",
+  "sphinx-tabs",
+  "sphinx_multiversion",
+]
+
+[project.optional-dependencies]
+cu128 = ["torch>=2.7.0"]
+cpu = ["torch>=2.7.0"]
+
+[tool.uv]
+conflicts = [
+  [{extra = "cu128"}, {extra = "cpu"}],
+]
+constraint-dependencies = [
+  "GitPython>=3.1.57",
+  "lxml>=6.1.0",
+]
+required-environments = [
+  "sys_platform == 'darwin' and platform_machine == 'arm64'",
+  "sys_platform == 'linux' and platform_machine == 'x86_64'",
+]
+
+[[tool.uv.index]]
+url = "https://pypi.org/simple"
+
+[[tool.uv.index]]
+name = "nvidia"
+url = "https://pypi.nvidia.com/"
+explicit = true
+
+[[tool.uv.index]]
+name = "pytorch-cu128"
+url = "https://download.pytorch.org/whl/cu128"
+explicit = true
+
+[[tool.uv.index]]
+name = "pytorch-cpu"
+url = "https://download.pytorch.org/whl/cpu"
+explicit = true
+
+[tool.uv.sources]
+warp-lang = { index = "nvidia", marker = "sys_platform != 'darwin'" }
+torch = [
+  { index = "pytorch-cu128", extra = "cu128", marker = "sys_platform != 'darwin'" },
+  { index = "pytorch-cpu", extra = "cpu", marker = "sys_platform != 'darwin'" },
+]
+
+[tool.ruff]
+src = ["src"]  # Helpful for recognizing first-party imports.
+indent-width = 2
+exclude = [
+  "src/mjlab/utils/lab_api",
+  "typings",
+]
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "I", "B"]
+ignore = ["B011"]
+
+[tool.pyright]
+pythonVersion = "3.10"
+venvPath = "."
+venv = ".venv"
+ignore = ["./typings", "./src/mjlab/utils/lab_api", "./docs"]
+stubPath = "typings"
+
+[tool.ty.environment]
+extra-paths = ["typings"]
+
+[tool.ty.src]
+include = ["src", "tests"]
+exclude = ["src/mjlab/utils/lab_api", "typings"]
+
+[tool.pytest.ini_options]
+markers = [
+  "slow: marks tests as slow (deselect with '-m \"not slow\"')",
+]
+addopts = "--strict-markers"
+filterwarnings = [
+  # MuJoCo Warp warns that MULTICCD (enabled by default) generates at most one
+  # contact for CCD pairs it lacks multicontact support for (e.g. cylinder-box,
+  # hfield-capsule). Test fixtures aren't validating contact fidelity for these
+  # pairs, so silence the expected noise.
+  "ignore:MULTICCD is enabled, but the scene contains CCD pairs:UserWarning",
+]
diff --git a/scripts/benchmarks/README.md b/scripts/benchmarks/README.md
new file mode 100644
index 0000000..fc302e4
--- /dev/null
+++ b/scripts/benchmarks/README.md
@@ -0,0 +1,76 @@
+# mjlab Nightly Benchmarks
+
+This directory contains scripts for automated nightly benchmarking of mjlab.
+
+## Overview
+
+The nightly benchmark system:
+1. Trains a tracking policy on the latest commit
+2. Evaluates the policy across 1024 trials
+3. Measures simulation throughput
+4. Generates an HTML report with historical trends
+5. Publishes results to GitHub Pages
+
+## Usage
+
+### Run the full nightly benchmark
+
+```bash
+./scripts/benchmarks/nightly_train.sh
+```
+
+### Skip training (regenerate report only)
+
+```bash
+SKIP_TRAINING=1 ./scripts/benchmarks/nightly_train.sh
+```
+
+### Skip training and throughput
+
+```bash
+SKIP_TRAINING=1 SKIP_THROUGHPUT=1 ./scripts/benchmarks/nightly_train.sh
+```
+
+### Regenerate report directly (no git operations)
+
+```bash
+uv run python scripts/benchmarks/generate_report.py \
+  --entity gcbc_researchers \
+  --tag nightly \
+  --output-dir benchmark_results
+```
+
+### Measure throughput only
+
+```bash
+uv run python scripts/benchmarks/measure_throughput.py \
+  --num-envs 4096 \
+  --output-dir benchmark_results
+```
+
+## Configuration
+
+Environment variables for `nightly_train.sh`:
+
+- `CUDA_DEVICE` - GPU device to use (default: 0)
+- `WANDB_TAGS` - Comma-separated tags for the run (default: nightly)
+- `SKIP_TRAINING` - Set to "1" to skip training
+- `SKIP_THROUGHPUT` - Set to "1" to skip throughput benchmarking
+
+## Automated Setup
+
+See [systemd/README.md](systemd/README.md) for instructions on setting up automated nightly runs using systemd timers.
+
+## Report Options
+
+The `generate_report.py` script supports:
+
+- `--eval-limit N` - Maximum number of NEW runs to evaluate per invocation (default: 10)
+  - Set to 0 for no limit
+  - Historical cached results are always preserved
+- `--tag TAG` - Filter runs by WandB tag (default: "nightly")
+- `--num-envs N` - Number of parallel environments for evaluation (default: 1024)
+
+## Viewing Results
+
+Reports are published to: https://mujocolab.github.io/mjlab/nightly/
diff --git a/scripts/benchmarks/generate_report.py b/scripts/benchmarks/generate_report.py
new file mode 100644
index 0000000..fcffab8
--- /dev/null
+++ b/scripts/benchmarks/generate_report.py
@@ -0,0 +1,862 @@
+"""Generate benchmark report from evaluation metrics.
+
+This script runs policy evaluation on nightly runs and generates a static HTML
+dashboard for tracking policy performance over time.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+from datetime import datetime
+from pathlib import Path
+
+import tyro
+import wandb
+
+import mjlab
+from mjlab.tasks.tracking.scripts.evaluate import EvaluateConfig, run_evaluate
+
+# Metrics to display: (key, label, unit, scale, higher_is_better)
+METRICS = [
+  ("success_rate", "Success Rate", "%", 100, True),
+  ("mpkpe", "MPKPE", "m", 1, False),
+  ("r_mpkpe", "R-MPKPE", "m", 1, False),
+  ("ee_pos_error", "EE Position Error", "m", 1, False),
+  ("ee_ori_error", "EE Orientation Error", "rad", 1, False),
+  ("joint_vel_error", "Joint Velocity Error", "rad/s", 1, False),
+]
+
+
+def evaluate_run(run_path: str, num_envs: int = 1024) -> dict:
+  """Evaluate a single run and return metrics with metadata."""
+  api = wandb.Api()
+  run = api.run(run_path)
+
+  print(f"Evaluating run: {run.name} ({run.id})")
+
+  cfg = EvaluateConfig(wandb_run_path=run_path, num_envs=num_envs)
+  metrics = run_evaluate("Mjlab-Tracking-Flat-Unitree-G1", cfg)
+
+  # Get commit SHA from run metadata.
+  commit = run.commit or run.config.get("commit", "unknown")
+
+  return {
+    "id": run.id,
+    "name": run.name,
+    "url": run.url,
+    "created_at": run.created_at,
+    "commit": commit[:7] if len(commit) > 7 else commit,
+    "metrics": metrics,
+  }
+
+
+def load_throughput_data(output_dir: Path) -> list[dict]:
+  """Load throughput benchmark data if available."""
+  data_file = output_dir / "throughput_data.json"
+  if not data_file.exists():
+    return []
+  with open(data_file) as f:
+    return json.load(f)
+
+
+def generate_html_report(runs: list[dict], output_dir: Path) -> None:
+  """Generate static HTML dashboard from evaluation data."""
+  output_dir.mkdir(parents=True, exist_ok=True)
+
+  # Save raw data.
+  with open(output_dir / "data.json", "w") as f:
+    json.dump(runs, f, indent=2, default=str)
+
+  # Copy task images for the throughput dashboard.
+  images_src = Path(__file__).parent / "nightly_images"
+  if images_src.is_dir():
+    images_dst = output_dir / "images"
+    if images_dst.exists():
+      shutil.rmtree(images_dst)
+    shutil.copytree(images_src, images_dst)
+
+  # Load throughput data if available.
+  throughput_data = load_throughput_data(output_dir)
+
+  html = generate_dashboard_html(runs, throughput_data)
+  with open(output_dir / "index.html", "w") as f:
+    f.write(html)
+
+  print(f"Report generated at {output_dir / 'index.html'}")
+
+
+def generate_dashboard_html(runs: list[dict], throughput_data: list[dict]) -> str:
+  """Generate the HTML dashboard content."""
+  runs_json = json.dumps(runs, default=str)
+  metrics_json = json.dumps(METRICS)
+  throughput_json = json.dumps(throughput_data, default=str)
+  timestamp = datetime.now().strftime("%Y-%m-%d %H:%M")
+  github_repo = "https://github.com/mujocolab/mjlab"
+
+  return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>mjlab Nightly Benchmark</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/chartjs-adapter-date-fns"></script>
+    <style>
+        :root {{
+            --bg: #ffffff;
+            --bg-card: #f6f8fa;
+            --text: #1f2328;
+            --text-dim: #656d76;
+            --border: #d0d7de;
+            --accent: #0969da;
+            --green: #1a7f37;
+            --red: #cf222e;
+        }}
+        @media (prefers-color-scheme: dark) {{
+            :root:not([data-theme="light"]) {{
+                --bg: #0d1117;
+                --bg-card: #161b22;
+                --text: #c9d1d9;
+                --text-dim: #8b949e;
+                --border: #30363d;
+                --accent: #58a6ff;
+                --green: #3fb950;
+                --red: #f85149;
+            }}
+        }}
+        :root[data-theme="dark"] {{
+            --bg: #0d1117;
+            --bg-card: #161b22;
+            --text: #c9d1d9;
+            --text-dim: #8b949e;
+            --border: #30363d;
+            --accent: #58a6ff;
+            --green: #3fb950;
+            --red: #f85149;
+        }}
+        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
+        body {{
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+            background: var(--bg);
+            color: var(--text);
+            padding: 2rem;
+            max-width: 1400px;
+            margin: 0 auto;
+        }}
+        header {{
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 2rem;
+            padding-bottom: 1rem;
+            border-bottom: 1px solid var(--border);
+        }}
+        h1 {{ font-size: 1.5rem; }}
+        .subtitle {{
+            font-size: 0.875rem;
+            color: var(--text-dim);
+            margin-top: 0.25rem;
+        }}
+        .timestamp {{ color: var(--text-dim); font-size: 0.875rem; }}
+        .charts {{
+            display: grid;
+            grid-template-columns: 1fr;
+            gap: 1.5rem;
+            margin-bottom: 2rem;
+        }}
+        .chart-card {{
+            background: var(--bg-card);
+            border: 1px solid var(--border);
+            border-radius: 8px;
+            padding: 1rem;
+        }}
+        .chart-title {{
+            font-size: 0.875rem;
+            font-weight: 500;
+            margin-bottom: 0.5rem;
+            display: flex;
+            justify-content: space-between;
+        }}
+        .chart-value {{ color: var(--text-dim); }}
+        .chart-container {{ height: 350px; }}
+        a {{ color: var(--accent); text-decoration: none; }}
+        a:hover {{ text-decoration: underline; }}
+        .theme-toggle {{
+            background: var(--bg-card);
+            border: 1px solid var(--border);
+            border-radius: 6px;
+            padding: 0.5rem;
+            cursor: pointer;
+            color: var(--text);
+            font-size: 1rem;
+            line-height: 1;
+        }}
+        .theme-toggle:hover {{ border-color: var(--accent); }}
+        .header-right {{ display: flex; align-items: center; gap: 1rem; }}
+        .tabs {{
+            display: flex;
+            gap: 0.5rem;
+            margin-bottom: 1.5rem;
+        }}
+        .tab {{
+            background: var(--bg-card);
+            border: 1px solid var(--border);
+            border-radius: 6px;
+            padding: 0.5rem 1rem;
+            cursor: pointer;
+            color: var(--text);
+            font-size: 0.875rem;
+            font-weight: 500;
+        }}
+        .tab:hover {{ border-color: var(--accent); }}
+        .tab.active {{
+            background: var(--accent);
+            border-color: var(--accent);
+            color: white;
+        }}
+        .range-selector {{
+            display: flex;
+            gap: 0.4rem;
+            margin-bottom: 1rem;
+        }}
+        .range-btn {{
+            background: var(--bg-card);
+            border: 1px solid var(--border);
+            border-radius: 6px;
+            padding: 0.3rem 0.75rem;
+            cursor: pointer;
+            color: var(--text);
+            font-size: 0.8rem;
+            font-weight: 500;
+        }}
+        .range-btn:hover {{ border-color: var(--accent); }}
+        .range-btn.active {{
+            background: var(--accent);
+            border-color: var(--accent);
+            color: white;
+        }}
+        .tab-content {{ display: none; }}
+        .tab-content.active {{ display: block; }}
+        .tab-description {{
+            font-size: 0.875rem;
+            color: var(--text-dim);
+            margin-bottom: 1.5rem;
+            line-height: 1.5;
+        }}
+        .task-grid {{
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+            gap: 1rem;
+            margin-bottom: 1.5rem;
+        }}
+        .task-card {{
+            background: var(--bg-card);
+            border: 2px solid var(--border);
+            border-radius: 10px;
+            padding: 0.75rem;
+            cursor: pointer;
+            transition: border-color 0.15s, box-shadow 0.15s;
+            text-align: center;
+        }}
+        .task-card:hover {{ border-color: var(--accent); }}
+        .task-card.active {{
+            border-color: var(--accent);
+            box-shadow: 0 0 0 1px var(--accent);
+        }}
+        .task-card img {{
+            width: 100%;
+            aspect-ratio: 16/10;
+            object-fit: cover;
+            border-radius: 6px;
+            margin-bottom: 0.5rem;
+            background: var(--border);
+        }}
+        .task-card .task-name {{
+            font-size: 0.85rem;
+            font-weight: 600;
+        }}
+        .task-card .task-stat {{
+            font-size: 0.75rem;
+            color: var(--text-dim);
+            margin-top: 0.2rem;
+        }}
+        .task-chart-area {{
+            display: none;
+        }}
+        .task-chart-area.active {{
+            display: block;
+        }}
+        footer {{
+            margin-top: 3rem;
+            padding-top: 1.5rem;
+            border-top: 1px solid var(--border);
+            font-size: 0.8rem;
+            color: var(--text-dim);
+            line-height: 1.6;
+        }}
+        @media (max-width: 600px) {{
+            body {{ padding: 1rem; }}
+            h1 {{ font-size: 1.25rem; }}
+            .tabs {{ flex-wrap: wrap; }}
+            .task-grid {{ grid-template-columns: 1fr; }}
+        }}
+    </style>
+</head>
+<body>
+    <header>
+        <div>
+            <h1><a href="{github_repo}" style="color:inherit;text-decoration:none">mjlab</a> Nightly Benchmark</h1>
+            <div class="subtitle">Performance tracking over time</div>
+        </div>
+        <div class="header-right">
+            <span class="timestamp">Updated: {timestamp}</span>
+            <button class="theme-toggle" id="theme-toggle" title="Toggle theme">
+                <span id="theme-icon"></span>
+            </button>
+        </div>
+    </header>
+
+    <div class="tabs">
+        <button class="tab active" data-tab="tracking">Tracking Eval</button>
+        <button class="tab" data-tab="throughput">Throughput</button>
+    </div>
+
+    <div id="tracking" class="tab-content active">
+        <p class="tab-description">Nightly motion imitation training and evaluation on Unitree G1 (1024 trials per run).</p>
+        <div class="range-selector" id="range-selector">
+            <button class="range-btn" data-days="30">30d</button>
+            <button class="range-btn active" data-days="90">90d</button>
+            <button class="range-btn" data-days="180">180d</button>
+            <button class="range-btn" data-days="0">All</button>
+        </div>
+        <div class="charts" id="charts"></div>
+    </div>
+
+    <div id="throughput" class="tab-content">
+        <p class="tab-description">Physics simulation throughput across tasks (4096 parallel envs, NVIDIA RTX 5090).</p>
+        <div class="task-grid" id="task-grid"></div>
+        <div class="range-selector" id="range-selector-tp">
+            <button class="range-btn" data-days="30">30d</button>
+            <button class="range-btn active" data-days="90">90d</button>
+            <button class="range-btn" data-days="180">180d</button>
+            <button class="range-btn" data-days="0">All</button>
+        </div>
+        <div id="task-chart-panels"></div>
+    </div>
+
+    <footer>
+        These benchmarks run nightly using the latest commit.<br>
+        GPU: NVIDIA RTX 5090
+    </footer>
+
+    <script>
+        // Theme toggle logic
+        const themeToggle = document.getElementById('theme-toggle');
+        const themeIcon = document.getElementById('theme-icon');
+        const root = document.documentElement;
+
+        function getSystemTheme() {{
+            return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+        }}
+
+        function getEffectiveTheme() {{
+            const stored = localStorage.getItem('theme');
+            if (stored === 'dark' || stored === 'light') return stored;
+            return getSystemTheme();
+        }}
+
+        function updateThemeIcon() {{
+            const stored = localStorage.getItem('theme');
+            if (!stored) {{
+                themeIcon.textContent = '\u2699\ufe0f'; // gear for auto
+                themeToggle.title = 'Theme: System (click to toggle)';
+            }} else if (stored === 'dark') {{
+                themeIcon.textContent = '\U0001f319'; // moon
+                themeToggle.title = 'Theme: Dark (click to toggle)';
+            }} else {{
+                themeIcon.textContent = '\u2600\ufe0f'; // sun
+                themeToggle.title = 'Theme: Light (click to toggle)';
+            }}
+        }}
+
+        function applyTheme() {{
+            const stored = localStorage.getItem('theme');
+            if (stored) {{
+                root.setAttribute('data-theme', stored);
+            }} else {{
+                root.removeAttribute('data-theme');
+            }}
+            updateThemeIcon();
+            updateChartColors();
+        }}
+
+        function cycleTheme() {{
+            const stored = localStorage.getItem('theme');
+            if (!stored) {{
+                // auto -> dark
+                localStorage.setItem('theme', 'dark');
+            }} else if (stored === 'dark') {{
+                // dark -> light
+                localStorage.setItem('theme', 'light');
+            }} else {{
+                // light -> auto
+                localStorage.removeItem('theme');
+            }}
+            applyTheme();
+        }}
+
+        themeToggle.addEventListener('click', cycleTheme);
+        window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', applyTheme);
+
+        const runs = {runs_json};
+        const METRICS = {metrics_json};
+        const GITHUB_REPO = '{github_repo}';
+
+        // Sort by date ascending for charts.
+        runs.sort((a, b) => new Date(a.created_at) - new Date(b.created_at));
+
+        const colors = {{
+            success_rate: '#3fb950',
+            mpkpe: '#58a6ff',
+            r_mpkpe: '#a371f7',
+            ee_pos_error: '#f0883e',
+            ee_ori_error: '#f85149',
+            joint_vel_error: '#79c0ff'
+        }};
+
+        let charts = [];
+        let trackingCharts = [];
+        let throughputCharts = [];
+
+        function updateChartColors() {{
+            const style = getComputedStyle(root);
+            const textDim = style.getPropertyValue('--text-dim').trim();
+            const border = style.getPropertyValue('--border').trim();
+            const isDark = getEffectiveTheme() === 'dark';
+            const gridColor = isDark ? '#3a424b' : '#d0d7de';
+            Chart.defaults.color = textDim;
+            Chart.defaults.borderColor = gridColor;
+            charts.forEach(c => c.update());
+        }}
+
+        // Initialize theme before creating charts so grid colors are correct.
+        applyTheme();
+
+        // Charts
+        const chartsContainer = document.getElementById('charts');
+
+        // Compute a rolling average over the last `window` points.
+        function rollingAvg(data, window) {{
+            return data.map((d, i) => {{
+                const start = Math.max(0, i - window + 1);
+                const slice = data.slice(start, i + 1);
+                const avg = slice.reduce((s, p) => s + p.y, 0) / slice.length;
+                return {{ x: d.x, y: avg }};
+            }});
+        }}
+
+        const AVG_WINDOW = 7;
+
+        METRICS.forEach(([key, label, unit, scale, higherIsBetter]) => {{
+            const data = runs.map(r => ({{
+                x: new Date(r.created_at),
+                y: r.metrics[key] * scale,
+                commit: r.commit,
+                name: r.name
+            }}));
+
+            const avgData = rollingAvg(data, AVG_WINDOW);
+            const color = colors[key] || '#58a6ff';
+
+            const latestVal = data[data.length - 1]?.y;
+            const arrow = higherIsBetter ? '\u2191' : '\u2193';
+            const tooltip = higherIsBetter ? 'Higher is better' : 'Lower is better';
+
+            const card = document.createElement('div');
+            card.className = 'chart-card';
+            card.innerHTML = `
+                <div class="chart-title">
+                    <span>${{label}} <span title="${{tooltip}}" style="cursor:help;opacity:0.6">${{arrow}}</span></span>
+                    <span class="chart-value">${{latestVal?.toFixed(3)}} ${{unit}}</span>
+                </div>
+                <div class="chart-container"><canvas></canvas></div>
+            `;
+            chartsContainer.appendChild(card);
+
+            const chart = new Chart(card.querySelector('canvas'), {{
+                type: 'line',
+                data: {{
+                    datasets: [
+                        {{
+                            label: label,
+                            data: data,
+                            borderColor: color,
+                            backgroundColor: color + '20',
+                            borderWidth: 2,
+                            pointRadius: 2,
+                            pointHoverRadius: 5,
+                            tension: 0.1,
+                            fill: true
+                        }},
+                        {{
+                            label: `${{AVG_WINDOW}}-run avg`,
+                            data: avgData,
+                            borderColor: color,
+                            borderWidth: 2,
+                            borderDash: [6, 4],
+                            pointRadius: 0,
+                            tension: 0.3,
+                            fill: false
+                        }}
+                    ]
+                }},
+                options: {{
+                    responsive: true,
+                    maintainAspectRatio: false,
+                    onClick: (event, elements) => {{
+                        if (elements.length > 0 && elements[0].datasetIndex === 0) {{
+                            const d = data[elements[0].index];
+                            if (d?.commit && d.commit !== 'unknown') {{
+                                window.open(`${{GITHUB_REPO}}/commit/${{d.commit}}`, '_blank');
+                            }}
+                        }}
+                    }},
+                    plugins: {{
+                        legend: {{
+                            display: true,
+                            position: 'bottom',
+                            labels: {{ usePointStyle: true, pointStyle: 'line', boxHeight: 1 }}
+                        }},
+                        tooltip: {{
+                            filter: (item) => item.datasetIndex === 0,
+                            callbacks: {{
+                                title: (items) => {{
+                                    const d = items[0]?.raw;
+                                    return d ? `${{d.name}} (${{d.commit}})` : '';
+                                }},
+                                label: (item) => {{
+                                    const d = item.raw;
+                                    return `${{label}}: ${{d.y?.toFixed(4)}} ${{unit}}`;
+                                }},
+                                footer: (items) => {{
+                                    const d = items[0]?.raw;
+                                    return d?.commit && d.commit !== 'unknown' ? 'Click to view commit' : '';
+                                }}
+                            }}
+                        }}
+                    }},
+                    scales: {{
+                        x: {{
+                            type: 'time',
+                            time: {{ unit: 'day' }},
+                            ticks: {{ maxTicksLimit: 5 }},
+                            title: {{
+                                display: true,
+                                text: 'Date',
+                                font: {{ size: 11 }}
+                            }}
+                        }},
+                        y: {{
+                            ticks: {{ maxTicksLimit: 5 }},
+                            title: {{
+                                display: true,
+                                text: unit,
+                                font: {{ size: 11 }}
+                            }}
+                        }}
+                    }}
+                }}
+            }});
+            charts.push(chart);
+            trackingCharts.push(chart);
+        }});
+
+        // Tab switching
+        document.querySelectorAll('.tab').forEach(tab => {{
+            tab.addEventListener('click', () => {{
+                document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
+                document.querySelectorAll('.tab-content').forEach(c => c.classList.remove('active'));
+                tab.classList.add('active');
+                document.getElementById(tab.dataset.tab).classList.add('active');
+                // Update URL hash
+                history.replaceState(null, '', '#' + tab.dataset.tab);
+            }});
+        }});
+
+        // Handle URL hash on load
+        if (window.location.hash) {{
+            const tab = document.querySelector(`.tab[data-tab="${{window.location.hash.slice(1)}}"]`);
+            if (tab) tab.click();
+        }}
+
+        // Throughput data and task cards
+        const throughputData = {throughput_json};
+        const taskGrid = document.getElementById('task-grid');
+        const taskChartPanels = document.getElementById('task-chart-panels');
+
+        // Task metadata: display name and image path (relative to nightly/)
+        const taskMeta = {{
+            'Mjlab-Velocity-Flat-Unitree-Go1': {{ name: 'Velocity \u2014 Go1', img: 'images/velocity_go1.png' }},
+            'Mjlab-Tracking-Flat-Unitree-G1': {{ name: 'Tracking \u2014 G1', img: 'images/tracking_g1.png' }},
+            'Mjlab-Lift-Cube-Yam': {{ name: 'Lift Cube \u2014 Yam', img: 'images/lift_cube_yam.png' }}
+        }};
+
+        const throughputChartInstances = {{}};
+
+        if (throughputData.length > 0) {{
+            const tasks = [...new Set(throughputData.flatMap(d => d.results.map(r => r.task)))];
+            const latestRun = throughputData[throughputData.length - 1];
+
+            tasks.forEach((task, i) => {{
+                const meta = taskMeta[task] || {{ name: task, img: '' }};
+                const latestResult = latestRun?.results.find(r => r.task === task);
+                const latestSps = latestResult ? `${{(latestResult.env_sps / 1000).toFixed(0)}}K env steps/s` : '';
+
+                // Card
+                const card = document.createElement('div');
+                card.className = 'task-card' + (i === 0 ? ' active' : '');
+                card.dataset.task = task;
+                card.innerHTML = `
+                    <img src="${{meta.img}}" alt="${{meta.name}}" onerror="this.style.display='none'">
+                    <div class="task-name">${{meta.name}}</div>
+                    <div class="task-stat">${{latestSps}}</div>
+                `;
+                taskGrid.appendChild(card);
+
+                // Chart panel
+                const panel = document.createElement('div');
+                panel.className = 'task-chart-area' + (i === 0 ? ' active' : '');
+                panel.id = `task-panel-${{i}}`;
+                panel.innerHTML = `
+                    <div class="chart-card">
+                        <div class="chart-title">
+                            <span>${{meta.name}} \u2014 Throughput</span>
+                        </div>
+                        <div class="chart-container"><canvas></canvas></div>
+                    </div>
+                `;
+                taskChartPanels.appendChild(panel);
+
+                // Build datasets
+                const envData = [];
+                const physicsData = [];
+                throughputData.forEach(run => {{
+                    const result = run.results.find(r => r.task === task);
+                    if (!result) return;
+                    const point = {{ x: new Date(run.created_at), commit: run.commit }};
+                    envData.push({{ ...point, y: result.env_sps / 1000 }});
+                    physicsData.push({{ ...point, y: result.physics_sps / 1000 }});
+                }});
+
+                const chart = new Chart(panel.querySelector('canvas'), {{
+                    type: 'line',
+                    data: {{
+                        datasets: [
+                            {{
+                                label: 'Env SPS',
+                                data: envData,
+                                borderColor: '#58a6ff',
+                                backgroundColor: '#58a6ff20',
+                                borderWidth: 2,
+                                pointRadius: 2,
+                                pointHoverRadius: 5,
+                                tension: 0.1,
+                                fill: true
+                            }},
+                            {{
+                                label: 'Physics SPS',
+                                data: physicsData,
+                                borderColor: '#3fb950',
+                                backgroundColor: '#3fb95020',
+                                borderWidth: 2,
+                                pointRadius: 2,
+                                pointHoverRadius: 5,
+                                tension: 0.1,
+                                fill: true
+                            }}
+                        ]
+                    }},
+                    options: {{
+                        responsive: true,
+                        maintainAspectRatio: false,
+                        onClick: (event, elements) => {{
+                            if (elements.length > 0) {{
+                                const di = elements[0].datasetIndex;
+                                const idx = elements[0].index;
+                                const d = di === 0 ? envData[idx] : physicsData[idx];
+                                if (d?.commit && d.commit !== 'unknown') {{
+                                    window.open(`${{GITHUB_REPO}}/commit/${{d.commit}}`, '_blank');
+                                }}
+                            }}
+                        }},
+                        plugins: {{
+                            legend: {{ display: true, position: 'bottom' }},
+                            tooltip: {{
+                                mode: 'index',
+                                callbacks: {{
+                                    title: (items) => {{
+                                        const d = items[0]?.raw;
+                                        return d ? `Commit: ${{d.commit}}` : '';
+                                    }},
+                                    label: (item) => {{
+                                        return `${{item.dataset.label}}: ${{item.raw.y?.toFixed(0)}}K steps/s`;
+                                    }},
+                                    afterBody: (items) => {{
+                                        if (items.length >= 2) {{
+                                            const envY = items[0]?.raw?.y || 0;
+                                            const physY = items[1]?.raw?.y || 0;
+                                            const overhead = physY > 0 ? ((1 - envY / physY) * 100).toFixed(1) : '?';
+                                            return `Overhead: ${{overhead}}%`;
+                                        }}
+                                        return '';
+                                    }},
+                                    footer: (items) => {{
+                                        const d = items[0]?.raw;
+                                        return d?.commit && d.commit !== 'unknown' ? 'Click to view commit' : '';
+                                    }}
+                                }}
+                            }}
+                        }},
+                        scales: {{
+                            x: {{
+                                type: 'time',
+                                time: {{ unit: 'day' }},
+                                ticks: {{ maxTicksLimit: 5 }},
+                                title: {{ display: true, text: 'Date', font: {{ size: 11 }} }}
+                            }},
+                            y: {{
+                                ticks: {{ maxTicksLimit: 5 }},
+                                title: {{
+                                    display: true,
+                                    text: 'K steps/s',
+                                    font: {{ size: 11 }}
+                                }}
+                            }}
+                        }}
+                    }}
+                }});
+                charts.push(chart);
+                throughputCharts.push(chart);
+                throughputChartInstances[task] = {{ chart, panelId: `task-panel-${{i}}` }};
+
+                // Card click handler
+                card.addEventListener('click', () => {{
+                    document.querySelectorAll('.task-card').forEach(c => c.classList.remove('active'));
+                    document.querySelectorAll('.task-chart-area').forEach(p => p.classList.remove('active'));
+                    card.classList.add('active');
+                    panel.classList.add('active');
+                    // Trigger resize so chart renders at correct size
+                    throughputChartInstances[task].chart.resize();
+                }});
+            }});
+        }} else {{
+            taskGrid.innerHTML = '<p style="color: var(--text-dim)">No throughput data available. Run measure_throughput.py to generate data.</p>';
+        }}
+
+        // Date-range windowing across both tracking and throughput charts.
+        // Setting min and clearing max also resets any zoom/pan.
+        function setRange(days) {{
+            const min = days > 0 ? Date.now() - days * 86400000 : undefined;
+            [...trackingCharts, ...throughputCharts].forEach(c => {{
+                c.options.scales.x.min = min;
+                c.options.scales.x.max = undefined;
+                c.update();
+            }});
+            document.querySelectorAll('.range-btn').forEach(b =>
+                b.classList.toggle('active', parseInt(b.dataset.days) === days));
+        }}
+        document.querySelectorAll('.range-btn').forEach(btn => {{
+            btn.addEventListener('click', () => setRange(parseInt(btn.dataset.days)));
+        }});
+        setRange(90);
+    </script>
+</body>
+</html>
+"""
+
+
+def load_cached_results(output_dir: Path) -> dict[str, dict]:
+  """Load previously evaluated results from cache."""
+  data_file = output_dir / "data.json"
+  if not data_file.exists():
+    return {}
+
+  with open(data_file) as f:
+    runs = json.load(f)
+
+  return {run["id"]: run for run in runs}
+
+
+def main(
+  run_paths: list[str] | None = None,
+  entity: str = "gcbc_researchers",
+  project: str = "mjlab",
+  tag: str = "nightly",
+  eval_limit: int = 0,
+  num_envs: int = 1024,
+  output_dir: Path = Path("benchmark_results"),
+) -> None:
+  """Generate benchmark report by evaluating nightly runs.
+
+  Args:
+    run_paths: Specific run paths to evaluate (entity/project/run_id).
+    entity: WandB entity.
+    project: WandB project name.
+    tag: Filter runs by tag.
+    eval_limit: Maximum number of NEW runs to evaluate per invocation (0 = no limit).
+    num_envs: Number of envs for evaluation.
+    output_dir: Output directory for generated report.
+  """
+  # Load cached results to avoid re-evaluating old runs.
+  cached = load_cached_results(output_dir)
+  print(f"Loaded {len(cached)} cached evaluation results")
+
+  # Start with all cached results (preserves historical data).
+  eval_results_by_id: dict[str, dict] = dict(cached)
+  new_evals = 0
+
+  if run_paths:
+    for run_path in run_paths:
+      run_id = run_path.split("/")[-1]
+      if run_id in eval_results_by_id:
+        print(f"Using cached result for {run_id}")
+      else:
+        try:
+          result = evaluate_run(run_path, num_envs)
+        except RuntimeError as e:
+          print(f"Skipping {run_path}: {e}")
+          continue
+        eval_results_by_id[run_id] = result
+        new_evals += 1
+  else:
+    api = wandb.Api()
+    print(f"Fetching runs from {entity}/{project} with tag '{tag}'...")
+    runs = api.runs(f"{entity}/{project}", filters={"tags": tag}, order="-created_at")
+
+    for run in runs:
+      if run.state != "finished":
+        continue
+
+      if run.id in eval_results_by_id:
+        print(f"Using cached result for {run.name} ({run.id})")
+      else:
+        if eval_limit > 0 and new_evals >= eval_limit:
+          print(f"Reached eval limit ({eval_limit}), skipping remaining new runs")
+          break
+        run_path = f"{entity}/{project}/{run.id}"
+        try:
+          result = evaluate_run(run_path, num_envs)
+        except RuntimeError as e:
+          print(f"Skipping {run.name} ({run.id}): {e}")
+          continue
+        eval_results_by_id[run.id] = result
+        new_evals += 1
+
+  eval_results = list(eval_results_by_id.values())
+  print(f"Total runs: {len(eval_results)} ({new_evals} newly evaluated)")
+  generate_html_report(eval_results, output_dir)
+
+
+if __name__ == "__main__":
+  tyro.cli(main, config=mjlab.TYRO_FLAGS)
diff --git a/scripts/benchmarks/measure_throughput.py b/scripts/benchmarks/measure_throughput.py
new file mode 100644
index 0000000..e2ef7af
--- /dev/null
+++ b/scripts/benchmarks/measure_throughput.py
@@ -0,0 +1,246 @@
+"""Measure environment throughput for regression tracking.
+
+This script measures physics and environment step throughput across canonical tasks
+to catch performance regressions in the manager-based API.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import time
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+
+import torch
+import tyro
+import wandb
+
+import mjlab
+import mjlab.tasks  # noqa: F401 - registers tasks
+from mjlab.envs import ManagerBasedRlEnv
+from mjlab.tasks.registry import load_env_cfg
+from mjlab.tasks.tracking.mdp.commands import MotionCommandCfg
+
+
+@dataclass
+class BenchmarkResult:
+  """Results from a single benchmark run."""
+
+  task: str
+  num_envs: int
+  num_steps: int
+  decimation: int
+  physics_sps: float
+  env_sps: float
+  overhead_pct: float
+
+  def __str__(self) -> str:
+    return (
+      f"{self.task} (dec={self.decimation}):\n"
+      f"  Physics SPS: {self.physics_sps:,.0f}\n"
+      f"  Env SPS:     {self.env_sps:,.0f}\n"
+      f"  Overhead:    {self.overhead_pct:.1f}%"
+    )
+
+  def to_dict(self) -> dict:
+    return asdict(self)
+
+
+@dataclass
+class ThroughputConfig:
+  """Configuration for throughput benchmarking."""
+
+  num_envs: int = 4096
+  """Number of parallel environments."""
+
+  num_steps: int = 200
+  """Number of steps to measure (after warmup)."""
+
+  warmup_steps: int = 50
+  """Number of warmup steps before measuring."""
+
+  device: str = "cuda:0"
+  """Device to run on."""
+
+  tasks: list[str] = field(
+    default_factory=lambda: [
+      "Mjlab-Velocity-Flat-Unitree-Go1",
+      "Mjlab-Tracking-Flat-Unitree-G1",
+      "Mjlab-Lift-Cube-Yam",
+    ]
+  )
+  """Tasks to benchmark."""
+
+  tracking_motion: str = "rll_humanoid/wandb-registry-Motions/lafan_cartwheel:latest"
+  """W&B artifact path for tracking task motion (entity/project/name:alias)."""
+
+  output_dir: Path | None = None
+  """Output directory for JSON results. If None, results are only printed."""
+
+
+def measure_physics_sps(env: ManagerBasedRlEnv, num_steps: int) -> float:
+  """Measure raw physics stepping in env steps per second.
+
+  Runs num_steps worth of physics (i.e., num_steps * decimation sim.step calls)
+  and reports throughput in env steps/sec for direct comparison with env.step().
+  """
+  decimation = env.cfg.decimation
+  total_physics_steps = num_steps * decimation
+
+  torch.cuda.synchronize()
+  start = time.perf_counter()
+
+  for _ in range(total_physics_steps):
+    env.sim.step()
+
+  torch.cuda.synchronize()
+  elapsed = time.perf_counter() - start
+
+  # Report in env steps/sec (not physics steps/sec) for fair comparison.
+  return (num_steps * env.num_envs) / elapsed
+
+
+def measure_env_sps(env: ManagerBasedRlEnv, num_steps: int) -> float:
+  """Measure full environment step throughput in env steps per second."""
+  action_dim = sum(env.action_manager.action_term_dim)
+  action = torch.zeros(env.num_envs, action_dim, device=env.device)
+
+  torch.cuda.synchronize()
+  start = time.perf_counter()
+
+  for _ in range(num_steps):
+    env.step(action)
+
+  torch.cuda.synchronize()
+  elapsed = time.perf_counter() - start
+
+  return (num_steps * env.num_envs) / elapsed
+
+
+def benchmark_task(task: str, cfg: ThroughputConfig) -> BenchmarkResult:
+  """Benchmark a single task."""
+  print(f"\nBenchmarking {task}...")
+
+  env_cfg = load_env_cfg(task)
+  env_cfg.scene.num_envs = cfg.num_envs
+
+  # Handle tracking task motion file.
+  if len(env_cfg.commands) > 0:
+    motion_cmd = env_cfg.commands.get("motion")
+    if isinstance(motion_cmd, MotionCommandCfg):
+      api = wandb.Api()
+      artifact = api.artifact(cfg.tracking_motion)
+      motion_dir = artifact.download()
+      motion_cmd.motion_file = str(Path(motion_dir) / "motion.npz")
+
+  env = ManagerBasedRlEnv(cfg=env_cfg, device=cfg.device)
+  env.reset()
+
+  # Warmup.
+  action_dim = sum(env.action_manager.action_term_dim)
+  action = torch.zeros(env.num_envs, action_dim, device=env.device)
+  for _ in range(cfg.warmup_steps):
+    env.step(action)
+  torch.cuda.synchronize()
+
+  decimation = env.cfg.decimation
+  physics_sps = measure_physics_sps(env, cfg.num_steps)
+
+  env.reset()
+  torch.cuda.synchronize()
+
+  env_sps = measure_env_sps(env, cfg.num_steps)
+
+  overhead_pct = 100 * (1 - env_sps / physics_sps)
+
+  env.close()
+
+  return BenchmarkResult(
+    task=task,
+    num_envs=cfg.num_envs,
+    num_steps=cfg.num_steps,
+    decimation=decimation,
+    physics_sps=physics_sps,
+    env_sps=env_sps,
+    overhead_pct=overhead_pct,
+  )
+
+
+def get_git_commit() -> str:
+  """Get current git commit SHA."""
+  try:
+    result = subprocess.run(
+      ["git", "rev-parse", "HEAD"],
+      capture_output=True,
+      text=True,
+      check=True,
+    )
+    return result.stdout.strip()[:7]
+  except subprocess.CalledProcessError:
+    return "unknown"
+
+
+def save_results(results: list[BenchmarkResult], output_dir: Path) -> None:
+  """Save benchmark results to JSON, appending to existing data."""
+  output_dir.mkdir(parents=True, exist_ok=True)
+  data_file = output_dir / "throughput_data.json"
+
+  # Load existing data.
+  existing: list[dict] = []
+  if data_file.exists():
+    with open(data_file) as f:
+      existing = json.load(f)
+
+  # Create new run entry.
+  run_entry = {
+    "created_at": datetime.now(timezone.utc).isoformat(),
+    "commit": get_git_commit(),
+    "results": [r.to_dict() for r in results],
+  }
+
+  existing.append(run_entry)
+
+  with open(data_file, "w") as f:
+    json.dump(existing, f, indent=2)
+
+  print(f"\nResults saved to {data_file}")
+
+
+def main(cfg: ThroughputConfig) -> list[BenchmarkResult]:
+  """Run throughput benchmarks on all configured tasks."""
+  print("Throughput Benchmark")
+  print(f"  Envs: {cfg.num_envs}")
+  print(f"  Steps: {cfg.num_steps} (+ {cfg.warmup_steps} warmup)")
+  print(f"  Device: {cfg.device}")
+
+  results = []
+  for task in cfg.tasks:
+    result = benchmark_task(task, cfg)
+    results.append(result)
+    print(result)
+
+  print("\n" + "=" * 74)
+  print("Summary (all values in env steps per second):")
+  print("  Physics SPS: sim.step() only (×decimation per env step)")
+  print("  Env SPS: full env.step() including managers")
+  print("  Overhead: time spent on non-physics work (observations, rewards, etc.)")
+  print("=" * 74)
+  print(f"{'Task':<35} {'Dec':>4} {'Physics SPS':>12} {'Env SPS':>12} {'Overhead':>8}")
+  print("-" * 74)
+  for r in results:
+    task_short = r.task.replace("Mjlab-", "").replace("-Unitree-", "-")
+    print(
+      f"{task_short:<35} {r.decimation:>4} {r.physics_sps:>12,.0f} {r.env_sps:>12,.0f} {r.overhead_pct:>7.1f}%"
+    )
+
+  if cfg.output_dir:
+    save_results(results, cfg.output_dir)
+
+  return results
+
+
+if __name__ == "__main__":
+  cfg = tyro.cli(ThroughputConfig, config=mjlab.TYRO_FLAGS)
+  main(cfg)
diff --git a/scripts/benchmarks/nightly_images/lift_cube_yam.png b/scripts/benchmarks/nightly_images/lift_cube_yam.png
new file mode 100644
index 0000000..b66bf42
Binary files /dev/null and b/scripts/benchmarks/nightly_images/lift_cube_yam.png differ
diff --git a/scripts/benchmarks/nightly_images/tracking_g1.png b/scripts/benchmarks/nightly_images/tracking_g1.png
new file mode 100644
index 0000000..342e2d6
Binary files /dev/null and b/scripts/benchmarks/nightly_images/tracking_g1.png differ
diff --git a/scripts/benchmarks/nightly_images/velocity_go1.png b/scripts/benchmarks/nightly_images/velocity_go1.png
new file mode 100644
index 0000000..c6b0e76
Binary files /dev/null and b/scripts/benchmarks/nightly_images/velocity_go1.png differ
diff --git a/scripts/benchmarks/nightly_train.sh b/scripts/benchmarks/nightly_train.sh
new file mode 100644
index 0000000..e5d44de
--- /dev/null
+++ b/scripts/benchmarks/nightly_train.sh
@@ -0,0 +1,152 @@
+#!/bin/bash
+# Nightly training script for mjlab benchmarks
+#
+# This script clones mjlab fresh, runs the tracking benchmark, and generates a report.
+# It is designed to be called by a systemd timer or cron job.
+#
+# Usage:
+#   ./scripts/benchmarks/nightly_train.sh
+#
+# Environment variables:
+#   CUDA_DEVICE: GPU device to use (default: 0)
+#   WANDB_TAGS: Comma-separated tags for the run (default: nightly)
+#   SKIP_TRAINING: Set to "1" to skip training and only generate report
+#   SKIP_THROUGHPUT: Set to "1" to skip throughput benchmarking
+
+set -euo pipefail
+
+# Configuration
+CUDA_DEVICE="${CUDA_DEVICE:-0}"
+WANDB_TAGS="${WANDB_TAGS:-(\"nightly\",)}"
+SKIP_TRAINING="${SKIP_TRAINING:-0}"
+SKIP_THROUGHPUT="${SKIP_THROUGHPUT:-0}"
+
+# Training configuration
+TASK="Mjlab-Tracking-Flat-Unitree-G1"
+NUM_ENVS=4096
+MAX_ITERATIONS=6000
+REGISTRY_NAME="rll_humanoid/wandb-registry-Motions/side_kick_test"
+
+REPO_URL="git@github.com:mujocolab/mjlab.git"
+GH_PAGES_BRANCH="gh-pages"
+WORK_DIR="/tmp/mjlab-nightly-$$"
+GH_PAGES_DIR="/tmp/mjlab-gh-pages-$$"
+
+log() {
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*"
+}
+
+error() {
+    log "ERROR: $*" >&2
+    exit 1
+}
+
+clear_gpu() {
+    local gpu_device="$1"
+    log "Clearing GPU $gpu_device..."
+    gpu_pids=$(nvidia-smi --query-compute-apps=pid --format=csv,noheader,nounits -i "$gpu_device" 2>/dev/null || true)
+    if [[ -n "$gpu_pids" ]]; then
+        for pid in $gpu_pids; do
+            log "Killing process $pid on GPU $gpu_device"
+            kill -9 "$pid" 2>/dev/null || true
+        done
+        sleep 2  # Wait for processes to fully terminate
+    fi
+}
+
+cleanup() {
+    if [[ -d "$WORK_DIR" ]]; then
+        log "Cleaning up work directory..."
+        rm -rf "$WORK_DIR"
+    fi
+    if [[ -d "$GH_PAGES_DIR" ]]; then
+        log "Cleaning up gh-pages clone..."
+        rm -rf "$GH_PAGES_DIR"
+    fi
+}
+trap cleanup EXIT
+
+export GIT_SSH_COMMAND="ssh -i \"$HOME/.ssh/mjlab_nightly_ed25519\" \
+    -o IdentitiesOnly=yes \
+    -o StrictHostKeyChecking=accept-new"
+
+# Clone fresh copy of mjlab
+log "Cloning mjlab..."
+git clone "$REPO_URL" "$WORK_DIR"
+cd "$WORK_DIR"
+
+log "Starting nightly benchmark run"
+log "Task: $TASK"
+log "GPU: $CUDA_DEVICE"
+log "Commit: $(git rev-parse HEAD)"
+
+# Run training
+if [[ "$SKIP_TRAINING" != "1" ]]; then
+    log "Starting training..."
+
+    clear_gpu "$CUDA_DEVICE"
+
+    CUDA_VISIBLE_DEVICES="$CUDA_DEVICE" uv run train "$TASK" \
+        --env.scene.num-envs "$NUM_ENVS" \
+        --agent.max-iterations "$MAX_ITERATIONS" \
+        --registry-name "$REGISTRY_NAME" \
+        --agent.wandb-tags "$WANDB_TAGS"
+
+    log "Training completed"
+else
+    log "Skipping training (SKIP_TRAINING=1)"
+fi
+
+# Clone gh-pages branch (shallow clone for speed)
+log "Cloning gh-pages branch..."
+if git ls-remote --exit-code --heads origin "$GH_PAGES_BRANCH" > /dev/null 2>&1; then
+    git clone --branch "$GH_PAGES_BRANCH" --depth 1 "$REPO_URL" "$GH_PAGES_DIR"
+else
+    # Create new gh-pages branch
+    mkdir -p "$GH_PAGES_DIR"
+    cd "$GH_PAGES_DIR"
+    git init
+    git remote add origin "$REPO_URL"
+    git checkout -b "$GH_PAGES_BRANCH"
+    cd "$WORK_DIR"
+fi
+
+# Copy cached data if exists
+REPORT_DIR="$GH_PAGES_DIR/nightly"
+mkdir -p "$REPORT_DIR"
+
+# Run throughput benchmark
+if [[ "$SKIP_THROUGHPUT" != "1" ]]; then
+    log "Running throughput benchmark..."
+
+    clear_gpu "$CUDA_DEVICE"
+
+    CUDA_VISIBLE_DEVICES="$CUDA_DEVICE" uv run python scripts/benchmarks/measure_throughput.py \
+        --num-envs "$NUM_ENVS" \
+        --output-dir "$REPORT_DIR"
+    log "Throughput benchmark completed"
+else
+    log "Skipping throughput benchmark (SKIP_THROUGHPUT=1)"
+fi
+
+# Generate report (uses cached data.json if present, only evaluates new runs)
+log "Generating benchmark report..."
+uv run python scripts/benchmarks/generate_report.py \
+    --entity gcbc_researchers \
+    --tag nightly \
+    --output-dir "$REPORT_DIR"
+
+log "Report generated"
+
+# Commit and push
+cd "$GH_PAGES_DIR"
+git add -A
+if git diff --staged --quiet; then
+    log "No changes to commit"
+else
+    git commit -m "Update nightly tracking benchmark $(date '+%Y-%m-%d')"
+    git push origin "$GH_PAGES_BRANCH" || log "Failed to push"
+    log "Deployed to GitHub Pages"
+fi
+
+log "Nightly benchmark complete"
diff --git a/scripts/benchmarks/systemd/README.md b/scripts/benchmarks/systemd/README.md
new file mode 100644
index 0000000..6ef303c
--- /dev/null
+++ b/scripts/benchmarks/systemd/README.md
@@ -0,0 +1,65 @@
+# Systemd Setup for Nightly Benchmarks
+
+This directory contains systemd user service and timer files for running nightly
+mjlab benchmarks.
+
+## Setup
+
+```bash
+# 1. Create user systemd directory if it doesn't exist
+mkdir -p ~/.config/systemd/user
+
+# 2. Copy the service and timer files
+cp mjlab-nightly.service ~/.config/systemd/user/
+cp mjlab-nightly.timer ~/.config/systemd/user/
+
+# 3. Edit the service file to set your WANDB_API_KEY
+#    Get your key from: https://wandb.ai/authorize
+nano ~/.config/systemd/user/mjlab-nightly.service
+
+# 4. Reload systemd
+systemctl --user daemon-reload
+
+# 5. Enable and start the timer
+systemctl --user enable mjlab-nightly.timer
+systemctl --user start mjlab-nightly.timer
+
+# 6. Enable lingering (so timer runs even when you're not logged in)
+sudo loginctl enable-linger $USER
+```
+
+## Useful Commands
+
+```bash
+# Check timer status
+systemctl --user status mjlab-nightly.timer
+
+# List all timers and when they'll run next
+systemctl --user list-timers
+
+# Run the benchmark manually (without waiting for timer)
+systemctl --user start mjlab-nightly.service
+
+# View logs
+journalctl --user -u mjlab-nightly.service -f
+
+# View recent logs
+journalctl --user -u mjlab-nightly.service --since "1 hour ago"
+
+# Disable the timer
+systemctl --user disable mjlab-nightly.timer
+```
+
+## Configuration
+
+Edit `~/.config/systemd/user/mjlab-nightly.service` to customize:
+
+- `Environment="CUDA_DEVICE=0"` - Which GPU to use
+- `Environment="WANDB_API_KEY=..."` - Your WandB API key
+- `MemoryMax=32G` - Memory limit for the training job
+
+Edit `~/.config/systemd/user/mjlab-nightly.timer` to change the schedule:
+
+- `OnCalendar=*-*-* 02:00:00` - Default: 2 AM daily
+- `OnCalendar=Mon *-*-* 02:00:00` - Example: Mondays only at 2 AM
+- `OnCalendar=*-*-* 02,14:00:00` - Example: Twice daily at 2 AM and 2 PM
diff --git a/scripts/benchmarks/systemd/mjlab-nightly.service b/scripts/benchmarks/systemd/mjlab-nightly.service
new file mode 100644
index 0000000..1712fc2
--- /dev/null
+++ b/scripts/benchmarks/systemd/mjlab-nightly.service
@@ -0,0 +1,38 @@
+# mjlab Nightly Benchmark Service
+#
+# Installation:
+#   1. Copy this file to ~/.config/systemd/user/mjlab-nightly.service
+#   2. Edit the paths below to match your setup
+#   3. Enable with: systemctl --user enable mjlab-nightly.timer
+#   4. Start with: systemctl --user start mjlab-nightly.timer
+#
+# To run manually: systemctl --user start mjlab-nightly.service
+# To check logs: journalctl --user -u mjlab-nightly.service
+
+[Unit]
+Description=mjlab Nightly Training Benchmark
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=oneshot
+
+# Update these paths to match your setup
+Environment="PATH=/home/kevin/.local/bin:/home/kevin/.cargo/bin:/usr/local/bin:/usr/bin:/bin"
+Environment="HOME=/home/kevin"
+Environment="CUDA_DEVICE=0"
+Environment="WANDB_API_KEY="
+
+WorkingDirectory=/home/kevin/dev/mjlab
+ExecStart=/home/kevin/dev/mjlab/scripts/benchmarks/nightly_train.sh
+
+# Logging
+StandardOutput=journal
+StandardError=journal
+
+# Resource limits (adjust as needed)
+Nice=10
+MemoryMax=32G
+
+[Install]
+WantedBy=default.target
diff --git a/scripts/benchmarks/systemd/mjlab-nightly.timer b/scripts/benchmarks/systemd/mjlab-nightly.timer
new file mode 100644
index 0000000..31149c0
--- /dev/null
+++ b/scripts/benchmarks/systemd/mjlab-nightly.timer
@@ -0,0 +1,28 @@
+# mjlab Nightly Benchmark Timer
+#
+# This timer triggers the nightly training run.
+# Default: 2:00 AM daily
+#
+# Installation:
+#   1. Copy to ~/.config/systemd/user/mjlab-nightly.timer
+#   2. Enable: systemctl --user enable mjlab-nightly.timer
+#   3. Start: systemctl --user start mjlab-nightly.timer
+#
+# Check status: systemctl --user list-timers
+# Check next run: systemctl --user status mjlab-nightly.timer
+
+[Unit]
+Description=Run mjlab nightly benchmarks
+
+[Timer]
+# Run at 2:00 AM every day
+OnCalendar=*-*-* 02:00:00
+
+# Add randomized delay up to 30 minutes to avoid thundering herd
+RandomizedDelaySec=1800
+
+# If missed (e.g., machine was off), run on next boot
+Persistent=true
+
+[Install]
+WantedBy=timers.target
diff --git a/scripts/cloud/README.md b/scripts/cloud/README.md
new file mode 100644
index 0000000..5a42204
--- /dev/null
+++ b/scripts/cloud/README.md
@@ -0,0 +1,3 @@
+# Cloud Training
+
+See the [Cloud Training](https://mjlab.readthedocs.io/en/latest/source/training/cloud.html) documentation for setup and usage.
diff --git a/scripts/cloud/sweep-agent.yaml b/scripts/cloud/sweep-agent.yaml
new file mode 100644
index 0000000..fda72c4
--- /dev/null
+++ b/scripts/cloud/sweep-agent.yaml
@@ -0,0 +1,17 @@
+# SkyPilot job that runs a single W&B sweep agent on one GPU.
+#
+# Submit to an existing cluster provisioned by sweep-cluster.yaml:
+#   sky exec mjlab-sweep scripts/cloud/sweep-agent.yaml \
+#     --gpus A100:1 --env SWEEP_ID=<entity/project/sweep_id> -d
+
+resources:
+  accelerators: A100:1
+
+envs:
+  SWEEP_ID: ""
+  MUJOCO_GL: egl
+
+run: |
+  source "$HOME/.local/bin/env" 2>/dev/null || true
+  cd ~/sky_workdir
+  uv run wandb agent "$SWEEP_ID"
diff --git a/scripts/cloud/sweep-cluster.yaml b/scripts/cloud/sweep-cluster.yaml
new file mode 100644
index 0000000..e55b761
--- /dev/null
+++ b/scripts/cloud/sweep-cluster.yaml
@@ -0,0 +1,34 @@
+# SkyPilot cluster definition for W&B sweep agents.
+#
+# Provisions a multi-GPU instance and installs dependencies. Does not
+# start any jobs. Use sweep-agent.yaml with sky exec for that.
+#
+# Usage:
+#   sky launch scripts/cloud/sweep-cluster.yaml -c mjlab-sweep --gpus A100:8
+
+name: mjlab-sweep-cluster
+
+resources:
+  cloud: lambda
+  accelerators: A100:8
+  autostop:
+    idle_minutes: 5
+    down: true
+
+workdir: .
+
+file_mounts:
+  ~/.netrc: ~/.netrc
+
+envs:
+  MUJOCO_GL: egl
+
+setup: |
+  # Install EGL for MuJoCo headless rendering.
+  sudo apt-get update && sudo apt-get install -y libegl-dev
+
+  # Install uv if not present.
+  command -v uv || curl -LsSf https://astral.sh/uv/install.sh | sh
+  source "$HOME/.local/bin/env" 2>/dev/null || true
+
+  uv sync --locked --no-dev
diff --git a/scripts/cloud/sweep-launch.sh b/scripts/cloud/sweep-launch.sh
new file mode 100644
index 0000000..df1d6be
--- /dev/null
+++ b/scripts/cloud/sweep-launch.sh
@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+# Launch a W&B sweep via SkyPilot.
+#
+# Provisions a single multi-GPU cluster and runs one sweep agent per GPU
+# using SkyPilot's job queue. Each agent pulls hyperparameters from the
+# W&B sweep controller independently.
+#
+# Usage:
+#   ./scripts/cloud/sweep-launch.sh [GPUS [CLOUD]]
+#
+# Examples:
+#   ./scripts/cloud/sweep-launch.sh A100:4          # 4 agents, default cloud
+#   ./scripts/cloud/sweep-launch.sh A100:8 gcp      # 8 agents on GCP
+#   ./scripts/cloud/sweep-launch.sh A100:8 lambda   # 8 agents on Lambda
+#   ./scripts/cloud/sweep-launch.sh                 # defaults to A100:4
+
+set -euo pipefail
+
+GPUS="${1:-A100:4}"
+CLOUD="${2:-}"
+GPU_TYPE="${GPUS%%:*}"
+NUM_AGENTS="${GPUS##*:}"
+CLUSTER_NAME="mjlab-sweep"
+
+echo "Creating W&B sweep..."
+SWEEP_ID=$(uv run wandb sweep scripts/cloud/sweep.yaml 2>&1 | grep "wandb agent" | awk '{print $NF}')
+
+if [ -z "$SWEEP_ID" ]; then
+  echo "Failed to create sweep."
+  exit 1
+fi
+
+echo "Sweep created: $SWEEP_ID"
+echo "Provisioning $GPUS cluster..."
+
+# Provision the cluster and run setup (no run section in this YAML).
+CLOUD_FLAG=${CLOUD:+--cloud "$CLOUD"}
+sky launch scripts/cloud/sweep-cluster.yaml \
+  -c "$CLUSTER_NAME" \
+  --gpus "$GPUS" \
+  ${CLOUD_FLAG} \
+  -y --retry-until-up
+
+echo "Submitting $NUM_AGENTS agents to job queue..."
+
+for i in $(seq 1 "$NUM_AGENTS"); do
+  echo "  Agent $i/$NUM_AGENTS"
+  sky exec "$CLUSTER_NAME" \
+    --gpus "${GPU_TYPE}:1" \
+    --env "SWEEP_ID=$SWEEP_ID" \
+    -d \
+    scripts/cloud/sweep-agent.yaml
+done
+
+echo ""
+echo "All agents launched. Monitor at:"
+echo "  sky queue $CLUSTER_NAME"
+echo "  sky logs $CLUSTER_NAME <JOB_ID>"
+echo "  W&B dashboard: https://wandb.ai/$SWEEP_ID"
+echo ""
+echo "When done: sky down $CLUSTER_NAME"
diff --git a/scripts/cloud/sweep.yaml b/scripts/cloud/sweep.yaml
new file mode 100644
index 0000000..9c0d3b9
--- /dev/null
+++ b/scripts/cloud/sweep.yaml
@@ -0,0 +1,37 @@
+# Example W&B sweep configuration. Customize the task, parameters, and
+# search space for your own experiment.
+#
+# Usage:
+#   ./scripts/cloud/sweep-launch.sh A100:4
+
+name: velocity-lr-entropy-sweep
+project: mjlab
+program: train
+method: random
+metric:
+  name: Train/mean_reward
+  goal: maximize
+
+parameters:
+  agent.algorithm.learning-rate:
+    distribution: log_uniform_values
+    min: 1e-4
+    max: 1e-2
+  agent.algorithm.entropy-coef:
+    distribution: log_uniform_values
+    min: 0.001
+    max: 0.1
+
+command:
+  - ${env}
+  - uv
+  - run
+  - ${program}
+  - Mjlab-Velocity-Flat-Unitree-G1
+  - --env.scene.num-envs
+  - "4096"
+  - --agent.max-iterations
+  - "6000"
+  - ${args}
+
+run_cap: 8
diff --git a/scripts/cloud/train-docker.yaml b/scripts/cloud/train-docker.yaml
new file mode 100644
index 0000000..ef6bd0f
--- /dev/null
+++ b/scripts/cloud/train-docker.yaml
@@ -0,0 +1,47 @@
+# SkyPilot task for launching mjlab training on Lambda Cloud.
+#
+# Uses the pre-built Docker image from GHCR.
+#
+# Usage:
+#   sky launch scripts/cloud/train-docker.yaml \
+#     --env TASK=Mjlab-Velocity-Flat-Unitree-G1
+
+name: mjlab-train
+
+resources:
+  cloud: lambda
+  accelerators: A100:1
+  autostop:
+    idle_minutes: 5
+    down: true  # Terminates the instance when idle (stops billing).
+
+workdir: .
+
+file_mounts:
+  ~/.netrc: ~/.netrc
+
+envs:
+  TASK: Mjlab-Velocity-Flat-Unitree-G1
+  NUM_ENVS: "4096"
+  MAX_ITERATIONS: "6000"
+  MUJOCO_GL: egl
+
+setup: |
+  # Configure NVIDIA runtime for Docker if not already set up.
+  if ! sudo docker info 2>/dev/null | grep -q "nvidia"; then
+    sudo nvidia-ctk runtime configure --runtime=docker
+    sudo systemctl restart docker
+    sleep 3  # Wait for the daemon to be ready before pulling.
+  fi
+
+  sudo docker pull ghcr.io/mujocolab/mjlab:latest
+
+run: |
+  sudo docker run --rm --runtime=nvidia --gpus all \
+    -v "$HOME/.netrc:/root/.netrc:ro" \
+    -e MUJOCO_GL=egl \
+    ghcr.io/mujocolab/mjlab:latest \
+    uv run --no-dev train "$TASK" \
+      --env.scene.num-envs "$NUM_ENVS" \
+      --agent.max-iterations "$MAX_ITERATIONS" \
+      --gpu-ids all
diff --git a/scripts/cloud/train.yaml b/scripts/cloud/train.yaml
new file mode 100644
index 0000000..642c30f
--- /dev/null
+++ b/scripts/cloud/train.yaml
@@ -0,0 +1,44 @@
+# SkyPilot task for launching mjlab training on Lambda Cloud.
+#
+# Installs mjlab directly with uv (no Docker).
+#
+# Usage:
+#   sky launch scripts/cloud/train.yaml \
+#     --env TASK=Mjlab-Velocity-Flat-Unitree-G1
+
+name: mjlab-train
+
+resources:
+  cloud: lambda
+  accelerators: A100:1
+  autostop:
+    idle_minutes: 5
+    down: true
+
+workdir: .
+
+file_mounts:
+  ~/.netrc: ~/.netrc
+
+envs:
+  TASK: Mjlab-Velocity-Flat-Unitree-G1
+  NUM_ENVS: "4096"
+  MAX_ITERATIONS: "6000"
+  MUJOCO_GL: egl
+
+setup: |
+  # Install EGL for MuJoCo headless rendering.
+  sudo apt-get update && sudo apt-get install -y libegl-dev
+
+  # Install uv if not present.
+  command -v uv || curl -LsSf https://astral.sh/uv/install.sh | sh
+  source "$HOME/.local/bin/env" 2>/dev/null || true
+
+  uv sync --locked --no-dev
+
+run: |
+  source "$HOME/.local/bin/env" 2>/dev/null || true
+  uv run train "$TASK" \
+    --env.scene.num-envs "$NUM_ENVS" \
+    --agent.max-iterations "$MAX_ITERATIONS" \
+    --gpu-ids all
diff --git a/scripts/demos/body_impulse.py b/scripts/demos/body_impulse.py
new file mode 100644
index 0000000..1d0e1c7
--- /dev/null
+++ b/scripts/demos/body_impulse.py
@@ -0,0 +1,194 @@
+"""Body impulse demo with force visualization.
+
+A cylinder hangs from a ball joint like a punching bag. Random impulses
+swing it around while magenta arrows show the applied forces. Both native
+and Viser viewers render the arrows via ``apply_body_impulse``'s built-in
+debug visualization.
+
+Run with:
+  uv run mjpython scripts/demos/body_impulse.py                      # macOS
+  uv run python scripts/demos/body_impulse.py                        # Linux
+  uv run python scripts/demos/body_impulse.py --viewer viser         # Viser
+"""
+
+from __future__ import annotations
+
+import math
+import os
+
+import mujoco
+import torch
+import tyro
+
+import mjlab
+from mjlab.entity import EntityCfg
+from mjlab.envs import ManagerBasedRlEnv, ManagerBasedRlEnvCfg
+from mjlab.envs.mdp.events import apply_body_impulse, reset_scene_to_default
+from mjlab.managers.event_manager import EventTermCfg
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.rl import RslRlVecEnvWrapper
+from mjlab.scene import SceneCfg
+from mjlab.utils.torch import configure_torch_backends
+from mjlab.viewer import NativeMujocoViewer, ViserPlayViewer
+
+BAG_RADIUS = 0.12  # punching bag radius
+BAG_HALF_HEIGHT = 0.25  # punching bag half-height
+BAG_DENSITY = 500.0  # ~5.7 kg
+ROPE_LEN = 0.3  # rope length in meters
+CEILING_Z = 1.0  # pivot height
+ROPE_RADIUS = 0.008  # visual rope thickness
+
+
+def create_pendulum_spec() -> mujoco.MjSpec:
+  spec = mujoco.MjSpec()
+  spec.modelname = "impulse_punching_bag"
+
+  # Ground plane.
+  ground = spec.worldbody.add_geom()
+  ground.type = mujoco.mjtGeom.mjGEOM_PLANE
+  ground.size[:] = (5.0, 5.0, 0.1)
+  ground.rgba[:] = (0.4, 0.5, 0.6, 1.0)
+
+  # Light.
+  light = spec.worldbody.add_light()
+  light.pos[:] = (0, 0, 4)
+  light.dir[:] = (0, 0, -1)
+  light.diffuse[:] = (0.8, 0.8, 0.8)
+
+  # Ceiling anchor (visual only).
+  anchor = spec.worldbody.add_geom()
+  anchor.type = mujoco.mjtGeom.mjGEOM_BOX
+  anchor.size[:] = (0.04, 0.04, 0.02)
+  anchor.pos[:] = (0, 0, CEILING_Z)
+  anchor.rgba[:] = (0.3, 0.3, 0.3, 1.0)
+  anchor.contype = 0
+  anchor.conaffinity = 0
+
+  # Pendulum body. Ball joint pivot is at (0, 0, CEILING_Z).
+  bag_body = spec.worldbody.add_body()
+  bag_body.name = "bag"
+  bag_body.pos[:] = (0, 0, CEILING_Z)
+
+  joint = bag_body.add_joint()
+  joint.name = "bag_joint"
+  joint.type = mujoco.mjtJoint.mjJNT_BALL
+  joint.damping[:] = 3.0
+  joint.frictionloss = 0.5
+
+  # Rope (visual only capsule from pivot to bag center).
+  rope = bag_body.add_geom()
+  rope.type = mujoco.mjtGeom.mjGEOM_CAPSULE
+  rope.size[:2] = (ROPE_RADIUS, ROPE_LEN / 2)
+  rope.pos[:] = (0, 0, -ROPE_LEN / 2)
+  rope.rgba[:] = (0.5, 0.4, 0.3, 1.0)
+  rope.contype = 0
+  rope.conaffinity = 0
+  rope.mass = 0.001  # negligible mass
+
+  # Punching bag cylinder hanging at the end of the rope.
+  geom = bag_body.add_geom()
+  geom.name = "bag_geom"
+  geom.type = mujoco.mjtGeom.mjGEOM_CYLINDER
+  geom.size[:2] = (BAG_RADIUS, BAG_HALF_HEIGHT)
+  geom.pos[:] = (0, 0, -ROPE_LEN - BAG_HALF_HEIGHT)
+  geom.density = BAG_DENSITY
+  geom.rgba[:] = (0.55, 0.15, 0.1, 0.35)
+
+  return spec
+
+
+def create_env_cfg() -> ManagerBasedRlEnvCfg:
+  bag_cfg = EntityCfg(
+    spec_fn=create_pendulum_spec,
+    init_state=EntityCfg.InitialStateCfg(
+      pos=(0.0, 0.0, 0.0),
+    ),
+  )
+
+  bag_mass = BAG_DENSITY * math.pi * BAG_RADIUS**2 * (2 * BAG_HALF_HEIGHT)
+  weight = bag_mass * 9.81
+  force_mag = weight * 0.8  # 0.8x body weight
+
+  cfg = ManagerBasedRlEnvCfg(
+    decimation=10,
+    scene=SceneCfg(
+      num_envs=1,
+      env_spacing=0.0,
+      extent=2.0,
+      entities={"bag": bag_cfg},
+    ),
+    events={
+      "reset_scene_to_default": EventTermCfg(
+        func=reset_scene_to_default,
+        mode="reset",
+      ),
+      "impulse": EventTermCfg(
+        func=apply_body_impulse,
+        mode="step",
+        params={
+          "force_range": (-force_mag, force_mag),
+          "torque_range": (-force_mag * 0.3, force_mag * 0.3),
+          "duration_s": (0.05, 0.1),
+          "cooldown_s": (1.0, 2.5),
+          "asset_cfg": SceneEntityCfg("bag", body_names=("bag",)),
+        },
+      ),
+    },
+  )
+
+  cfg.viewer.distance = 1.8
+  cfg.viewer.elevation = -10.0
+
+  return cfg
+
+
+class ZeroPolicy:
+  def __call__(self, obs: object) -> torch.Tensor:
+    del obs
+    return torch.zeros(1, 0)
+
+
+def main(device: str = "cpu", viewer: str = "auto") -> None:
+  configure_torch_backends()
+
+  env_cfg = create_env_cfg()
+  env = ManagerBasedRlEnv(cfg=env_cfg, device=device)
+  env = RslRlVecEnvWrapper(env)
+
+  # Print force scaling info.
+  mjm = env.unwrapped.sim.mj_model
+  bag_id = mujoco.mj_name2id(mjm, mujoco.mjtObj.mjOBJ_BODY, "bag")
+  subtree_mass = mjm.body_subtreemass[bag_id]
+  weight = subtree_mass * 9.81
+  bag_mass = BAG_DENSITY * math.pi * BAG_RADIUS**2 * (2 * BAG_HALF_HEIGHT)
+  force_mag = bag_mass * 9.81 * 0.8
+  print("=" * 50)
+  print("Body Impulse Demo (punching bag)")
+  print(f"  Bag mass         : {bag_mass:.2f} kg")
+  print(f"  Bag weight       : {weight:.2f} N")
+  print(f"  Rope length      : {ROPE_LEN} m")
+  print(f"  Force range      : +/-{force_mag:.0f} N")
+  print(f"  Force/weight     : {force_mag / weight:.1f}x")
+  print("=" * 50)
+
+  if viewer == "auto":
+    has_display = bool(os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY"))
+    resolved = "native" if has_display else "viser"
+  else:
+    resolved = viewer
+
+  policy = ZeroPolicy()
+  if resolved == "native":
+    print("Launching native viewer...")
+    NativeMujocoViewer(env, policy).run()
+  elif resolved == "viser":
+    print("Launching Viser viewer...")
+    ViserPlayViewer(env, policy).run()
+  else:
+    raise ValueError(f"Unknown viewer: {viewer}")
+
+  env.close()
+
+
+if __name__ == "__main__":
+  tyro.cli(main, config=mjlab.TYRO_FLAGS)
diff --git a/scripts/demos/contact_sensor_decimation.py b/scripts/demos/contact_sensor_decimation.py
new file mode 100644
index 0000000..5792159
--- /dev/null
+++ b/scripts/demos/contact_sensor_decimation.py
@@ -0,0 +1,271 @@
+"""Demo: contact sensor history catches collisions missed by decimation.
+
+A bouncing ball with high restitution contacts the ground briefly during each
+bounce. With large decimation, the contact may start and end within
+intermediate substeps, so by the final substep there is no active contact and
+instantaneous sensor reads miss it. Setting ``history_length = decimation``
+captures every substep.
+
+Run with:
+  uv run python scripts/demos/contact_sensor_decimation.py
+  uv run python scripts/demos/contact_sensor_decimation.py --viewer
+"""
+
+from __future__ import annotations
+
+import argparse
+import time
+
+import matplotlib.pyplot as plt
+import mujoco
+import numpy as np
+import torch
+
+from mjlab.entity import EntityCfg
+from mjlab.scene import Scene, SceneCfg
+from mjlab.sensor.contact_sensor import ContactMatch, ContactSensorCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+BOUNCING_BALL_XML = """
+<mujoco>
+  <option timestep="0.001"/>
+  <worldbody>
+    <body name="ground" pos="0 0 0">
+      <geom name="ground_geom" type="plane" size="5 5 0.1"/>
+    </body>
+    <body name="ball" pos="0 0 1">
+      <freejoint/>
+      <geom name="ball_geom" type="sphere" size="0.05" mass="0.1"
+            solref="-1000 0"/>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+DECIMATION = 20
+NUM_ENVS = 1
+NUM_POLICY_STEPS = 200
+PHYSICS_DT = 0.001
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+
+def build(history_length: int) -> tuple[Scene, Simulation]:
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(BOUNCING_BALL_XML))
+  sensor_cfg = ContactSensorCfg(
+    name="ball_contact",
+    primary=ContactMatch(mode="geom", pattern="ball_geom", entity="ball"),
+    secondary=None,
+    fields=("found", "force"),
+    history_length=history_length,
+  )
+  scene_cfg = SceneCfg(
+    num_envs=NUM_ENVS,
+    env_spacing=3.0,
+    entities={"ball": entity_cfg},
+    sensors=(sensor_cfg,),
+  )
+  scene = Scene(scene_cfg, DEVICE)
+  model = scene.compile()
+  sim = Simulation(
+    num_envs=NUM_ENVS,
+    cfg=SimulationCfg(njmax=50),
+    model=model,
+    device=DEVICE,
+  )
+  scene.initialize(sim.mj_model, sim.model, sim.data)
+  return scene, sim
+
+
+def run_no_history():
+  """Read instantaneous contact at the end of each policy step."""
+  scene, sim = build(history_length=0)
+  sensor = scene["ball_contact"]
+
+  contact_detected = []
+  for _ in range(NUM_POLICY_STEPS):
+    for _ in range(DECIMATION):
+      sim.step()
+      scene.update(dt=PHYSICS_DT)
+    found = sensor.data.found[0, 0].item() > 0
+    contact_detected.append(found)
+
+  return contact_detected
+
+
+def run_with_history():
+  """Read full substep history to catch mid-decimation contacts."""
+  scene, sim = build(history_length=DECIMATION)
+  sensor = scene["ball_contact"]
+
+  contact_detected_instant = []
+  contact_detected_history = []
+  ball_height_substep = []
+  for _ in range(NUM_POLICY_STEPS):
+    for _ in range(DECIMATION):
+      sim.step()
+      scene.update(dt=PHYSICS_DT)
+      # qpos is always current after step; qpos[2] is z for a freejoint.
+      ball_height_substep.append(sim.data.qpos[0, 2].item())
+    data = sensor.data
+    found_instant = data.found[0, 0].item() > 0
+    # Check whether any substep in the decimation window had contact.
+    force_hist = data.force_history  # [B, N, H, 3]
+    found_history = (force_hist[0, 0].norm(dim=-1) > 1e-6).any().item()
+    contact_detected_instant.append(found_instant)
+    contact_detected_history.append(found_history)
+
+  return contact_detected_instant, contact_detected_history, ball_height_substep
+
+
+def run_viewer():
+  """Launch a Viser viewer showing the bouncing ball with contact forces."""
+  import viser
+
+  from mjlab.viewer.viser import ViserMujocoScene
+
+  scene, sim = build(history_length=0)
+
+  server = viser.ViserServer(label="Bouncing Ball")
+  viz = ViserMujocoScene(server, sim.mj_model, num_envs=NUM_ENVS)
+  viz.show_contact_forces = True
+  viz.show_contact_points = True
+  viz.create_scene_gui(
+    camera_distance=2.0,
+    camera_azimuth=90.0,
+    camera_elevation=20.0,
+  )
+
+  print("Open the Viser URL above to watch the bouncing ball.")
+  print("Contact forces and points are enabled by default.")
+  print("Press Ctrl+C to stop.\n")
+
+  try:
+    while True:
+      for _ in range(DECIMATION):
+        sim.step()
+        scene.update(dt=PHYSICS_DT)
+      viz.update(sim.data)
+      if viz.needs_update:
+        viz.refresh_visualization()
+      time.sleep(DECIMATION * PHYSICS_DT)
+  except KeyboardInterrupt:
+    print("\nShutting down...")
+    server.stop()
+
+
+def run_analysis():
+  """Run the analysis comparing instantaneous vs history contact detection."""
+  print("=" * 70)
+  print("Contact Sensor Decimation Demo")
+  print(f"  Ball dropped from 1m, restitution ~ 1, decimation = {DECIMATION}")
+  print(f"  Physics dt = {PHYSICS_DT}s, policy dt = {DECIMATION * PHYSICS_DT}s")
+  print("=" * 70)
+
+  no_hist = run_no_history()
+  instant, history, ball_height = run_with_history()
+
+  # Policy steps where history caught a contact that instant missed.
+  missed = []
+  for i in range(NUM_POLICY_STEPS):
+    if history[i] and not instant[i]:
+      missed.append(i)
+
+  total_contacts_instant = sum(instant)
+  total_contacts_history = sum(history)
+  total_contacts_no_hist = sum(no_hist)
+
+  print()
+  print(f"Total policy steps with contact (no history):   {total_contacts_no_hist}")
+  print(f"Total policy steps with contact (instant only): {total_contacts_instant}")
+  print(f"Total policy steps with contact (with history): {total_contacts_history}")
+  print()
+
+  if missed:
+    print(f"Contacts MISSED by instantaneous read but CAUGHT by history: {len(missed)}")
+    print(f"  Policy steps: {missed}")
+  else:
+    print("No missed contacts (try increasing decimation or adjusting drop height)")
+
+  print()
+  print("Step-by-step (showing first 60 policy steps):")
+  print(f"{'step':>6}  {'no_hist':>8}  {'instant':>8}  {'history':>8}  {'missed':>8}")
+  print("-" * 50)
+  for i in range(min(60, NUM_POLICY_STEPS)):
+    flag = " <<<" if (history[i] and not instant[i]) else ""
+    print(f"{i:>6}  {no_hist[i]!s:>8}  {instant[i]!s:>8}  {history[i]!s:>8}  {flag}")
+
+  # --- Plot ---
+  total_substeps = NUM_POLICY_STEPS * DECIMATION
+  t_substep = np.arange(total_substeps) * PHYSICS_DT
+
+  # Place markers at the minimum height within each policy step window.
+  min_height = []
+  min_time = []
+  for i in range(NUM_POLICY_STEPS):
+    start = i * DECIMATION
+    end = (i + 1) * DECIMATION
+    window = ball_height[start:end]
+    j = int(np.argmin(window))
+    min_height.append(window[j])
+    min_time.append(t_substep[start + j])
+
+  # Separate history detections into: caught by both, caught only by history.
+  idx_both = [i for i in range(NUM_POLICY_STEPS) if instant[i] and history[i]]
+  idx_history_only = missed  # history=True, instant=False
+
+  fig, ax = plt.subplots(figsize=(12, 4))
+  ax.plot(t_substep, ball_height, color="0.4", linewidth=0.8, label="Ball height")
+
+  if idx_both:
+    ax.scatter(
+      [min_time[i] for i in idx_both],
+      [min_height[i] for i in idx_both],
+      color="tab:green",
+      s=40,
+      zorder=3,
+      label="Detected by both",
+    )
+
+  if idx_history_only:
+    ax.scatter(
+      [min_time[i] for i in idx_history_only],
+      [min_height[i] for i in idx_history_only],
+      color="tab:red",
+      s=60,
+      marker="x",
+      linewidths=2,
+      zorder=4,
+      label="Caught only by history",
+    )
+
+  ax.set_xlabel("Time (s)")
+  ax.set_ylabel("Ball height (m)")
+  ax.set_title(
+    f"Contact sensor with decimation = {DECIMATION}: "
+    f"{len(missed)} collisions missed without history"
+  )
+  ax.legend(loc="upper right")
+  ax.set_ylim(bottom=-0.05)
+  fig.tight_layout()
+  fig.savefig("scripts/demos/contact_sensor_decimation.png", dpi=150)
+  print("\nPlot saved to scripts/demos/contact_sensor_decimation.png")
+  plt.close(fig)
+
+
+def main():
+  parser = argparse.ArgumentParser(description=__doc__)
+  parser.add_argument(
+    "--viewer",
+    action="store_true",
+    help="Launch a Viser viewer instead of running the analysis.",
+  )
+  args = parser.parse_args()
+
+  if args.viewer:
+    run_viewer()
+  else:
+    run_analysis()
+
+
+if __name__ == "__main__":
+  main()
diff --git a/scripts/demos/differential_ik.py b/scripts/demos/differential_ik.py
new file mode 100644
index 0000000..3741bed
--- /dev/null
+++ b/scripts/demos/differential_ik.py
@@ -0,0 +1,194 @@
+"""Interactive IK control demo.
+
+Drag the 3D transform control in the viser viewer to move the YAM end-effector.
+
+Run with:
+  MJLAB_WARP_QUIET=1 uv run scripts/demos/differential_ik.py
+"""
+
+from __future__ import annotations
+
+import time
+from types import SimpleNamespace
+
+import torch
+import viser
+
+from mjlab.asset_zoo.robots.i2rt_yam.yam_constants import get_yam_robot_cfg
+from mjlab.entity import Entity, EntityCfg
+from mjlab.envs.mdp.actions import DifferentialIKAction, DifferentialIKActionCfg
+from mjlab.sim.sim import MujocoCfg, Simulation, SimulationCfg
+from mjlab.utils.lab_api.math import quat_from_matrix
+from mjlab.viewer.viser import ViserMujocoScene
+
+DEMO_INIT_STATE = EntityCfg.InitialStateCfg(
+  pos=(0.0, 0.0, 0.01),
+  joint_pos={
+    "joint2": 0.6,
+    "joint3": 0.6,
+    "joint4": 0.0,
+    "left_finger": 0.037,
+    "right_finger": -0.037,
+  },
+  joint_vel={".*": 0.0},
+)
+
+IK_ITERATIONS = 10
+
+
+def main() -> None:
+  device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+  robot_cfg = get_yam_robot_cfg()
+  robot_cfg.init_state = DEMO_INIT_STATE
+  entity = Entity(robot_cfg)
+  model = entity.compile()
+  sim_cfg = SimulationCfg(mujoco=MujocoCfg(gravity=(0, 0, -9.81)))
+  sim = Simulation(num_envs=1, cfg=sim_cfg, model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+  entity.write_joint_position_to_sim(entity.data.default_joint_pos, joint_ids=None)
+  sim.forward()
+
+  env = SimpleNamespace(num_envs=1, device=device, scene={"robot": entity}, sim=sim)
+  ik_cfg = DifferentialIKActionCfg(
+    entity_name="robot",
+    actuator_names=("joint.*",),
+    frame_name="grasp_site",
+    frame_type="site",
+    posture_weight=0.02,
+    joint_limit_weight=1e-1,
+    damping=1e-1,
+    use_relative_mode=False,
+  )
+  ik_action: DifferentialIKAction = ik_cfg.build(env)  # type: ignore[arg-type]
+  joint_ids = ik_action._joint_ids
+
+  grip_ids, _ = entity.find_joints("left_finger")
+  grip_joint_ids = torch.tensor(grip_ids, device=device, dtype=torch.long)
+  grip_open = torch.tensor([[0.037]], device=device)
+
+  server = viser.ViserServer(label="IK Control Demo")
+  scene = ViserMujocoScene(server, sim.mj_model, num_envs=1)
+  scene.create_scene_gui(
+    camera_distance=0.1,
+    camera_azimuth=135.0,
+    camera_elevation=30.0,
+  )
+
+  site_id = ik_action._frame_id
+  pos = sim.data.site_xpos[0, site_id].cpu().numpy()
+  xmat = sim.data.site_xmat[0, site_id]
+  quat = quat_from_matrix(xmat).cpu().numpy()
+
+  transform_ctrl = server.scene.add_transform_controls(
+    "/ik_target",
+    position=(float(pos[0]), float(pos[1]), float(pos[2])),
+    wxyz=(float(quat[0]), float(quat[1]), float(quat[2]), float(quat[3])),
+    scale=0.12,
+  )
+
+  needs_reset = [False]
+
+  with server.gui.add_folder("IK Control"):
+    reset_button = server.gui.add_button("Reset")
+    reset_button.on_click(lambda _: needs_reset.__setitem__(0, True))
+    iterations_slider = server.gui.add_slider(
+      "IK Iterations",
+      min=1,
+      max=50,
+      step=1,
+      initial_value=IK_ITERATIONS,
+    )
+
+  with server.gui.add_folder("IK Weights"):
+    damping_slider = server.gui.add_slider(
+      "Damping (λ)",
+      min=1e-2,
+      max=1.0,
+      step=1e-3,
+      initial_value=ik_cfg.damping,
+    )
+    pos_w_slider = server.gui.add_slider(
+      "Position Weight",
+      min=0.0,
+      max=10.0,
+      step=0.1,
+      initial_value=ik_cfg.position_weight,
+    )
+    ori_w_slider = server.gui.add_slider(
+      "Orientation Weight",
+      min=0.0,
+      max=10.0,
+      step=0.1,
+      initial_value=ik_cfg.orientation_weight,
+    )
+    jlim_w_slider = server.gui.add_slider(
+      "Joint Limit Weight",
+      min=0.0,
+      max=1.0,
+      step=0.01,
+      initial_value=ik_cfg.joint_limit_weight,
+    )
+    posture_w_slider = server.gui.add_slider(
+      "Posture Weight",
+      min=0.0,
+      max=1.0,
+      step=0.01,
+      initial_value=ik_cfg.posture_weight,
+    )
+
+  print("=" * 60)
+  print("IK Control Demo")
+  print("  Open the viser URL printed above")
+  print("  Drag the 3D transform control to move the end-effector")
+  print("=" * 60)
+
+  target_action = torch.zeros(1, 7, device=device)
+
+  def _reset() -> None:
+    entity.write_joint_position_to_sim(entity.data.default_joint_pos, joint_ids=None)
+    sim.forward()
+    ik_action.reset()
+    p = sim.data.site_xpos[0, site_id].cpu().numpy()
+    q = quat_from_matrix(sim.data.site_xmat[0, site_id]).cpu().numpy()
+    transform_ctrl.position = (float(p[0]), float(p[1]), float(p[2]))
+    transform_ctrl.wxyz = (float(q[0]), float(q[1]), float(q[2]), float(q[3]))
+
+  try:
+    while True:
+      if needs_reset[0]:
+        needs_reset[0] = False
+        _reset()
+
+      ik_cfg.damping = max(damping_slider.value, 1e-2)
+      ik_cfg.position_weight = max(pos_w_slider.value, 0.0)
+      ik_cfg.orientation_weight = max(ori_w_slider.value, 0.0)
+      ik_cfg.joint_limit_weight = max(jlim_w_slider.value, 0.0)
+      ik_cfg.posture_weight = max(posture_w_slider.value, 0.0)
+
+      p = transform_ctrl.position
+      w = transform_ctrl.wxyz
+      target_action[0, :3] = torch.tensor([p[0], p[1], p[2]], device=device)
+      target_action[0, 3:] = torch.tensor([w[0], w[1], w[2], w[3]], device=device)
+      ik_action.process_actions(target_action)
+
+      n_iter = int(iterations_slider.value)
+      for _ in range(n_iter):
+        dq = ik_action.compute_dq()
+        q = entity.data.joint_pos[:, joint_ids] + dq
+        entity.write_joint_position_to_sim(q, joint_ids=joint_ids)
+        entity.write_joint_position_to_sim(grip_open, joint_ids=grip_joint_ids)
+        sim.forward()
+
+      scene.update(sim.data)
+      if scene.needs_update:
+        scene.refresh_visualization()
+
+      time.sleep(1.0 / 30.0)
+  except KeyboardInterrupt:
+    print("\nShutting down...")
+    server.stop()
+
+
+if __name__ == "__main__":
+  main()
diff --git a/scripts/demos/flat_patch_terrain.py b/scripts/demos/flat_patch_terrain.py
new file mode 100644
index 0000000..4265c13
--- /dev/null
+++ b/scripts/demos/flat_patch_terrain.py
@@ -0,0 +1,125 @@
+"""Flat patch terrain demo.
+
+Spawns a Go1 on rough terrain with flat-patch sampling.
+On each reset, the robot lands on a flat patch.
+
+Run with:
+  uv run python scripts/demos/flat_patch_terrain.py [--viewer native|viser]
+
+Toggle visualization group 3 to see flat patch locations visualized as box sites.
+"""
+
+from __future__ import annotations
+
+import os
+
+import torch
+import tyro
+
+import mjlab
+import mjlab.terrains as terrain_gen
+from mjlab.envs import ManagerBasedRlEnv
+from mjlab.envs.mdp import events as mdp
+from mjlab.managers.event_manager import EventTermCfg
+from mjlab.rl import RslRlVecEnvWrapper
+from mjlab.tasks.velocity.config.go1.env_cfgs import unitree_go1_rough_env_cfg
+from mjlab.terrains import FlatPatchSamplingCfg
+from mjlab.terrains.terrain_generator import TerrainGeneratorCfg
+from mjlab.utils.torch import configure_torch_backends
+from mjlab.viewer import NativeMujocoViewer, ViserPlayViewer
+
+
+def main(viewer: str = "auto") -> None:
+  configure_torch_backends()
+  device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+  cfg = unitree_go1_rough_env_cfg(play=True)
+
+  spawn_patch_cfg = FlatPatchSamplingCfg(
+    num_patches=100,
+    patch_radius=0.3,
+    max_height_diff=0.05,
+  )
+
+  # Override terrain: 1 row x 2 cols, curriculum mode so each column is deterministic.
+  # Column 0 = discrete obstacles, Column 1 = pyramid slope.
+  assert cfg.scene.terrain is not None
+  cfg.scene.terrain.terrain_generator = TerrainGeneratorCfg(
+    size=(4.0, 4.0),
+    num_rows=1,
+    num_cols=2,
+    border_width=1.0,
+    curriculum=True,
+    add_lights=True,
+    sub_terrains={
+      "discrete_obstacles": terrain_gen.HfDiscreteObstaclesTerrainCfg(
+        proportion=0.5,
+        obstacle_height_range=(0.05, 0.5),
+        obstacle_width_range=(0.4, 1.2),
+        num_obstacles=30,
+        platform_width=1.5,
+        border_width=0.25,
+        flat_patch_sampling={"spawn": spawn_patch_cfg},
+      ),
+      "pyramid_slope": terrain_gen.HfPyramidSlopedTerrainCfg(
+        proportion=0.5,
+        slope_range=(0.3, 0.8),
+        platform_width=1.5,
+        border_width=0.25,
+        flat_patch_sampling={"spawn": spawn_patch_cfg},
+      ),
+    },
+  )
+
+  # Remove all termination conditions except time limit.
+  for key in list(cfg.terminations):
+    if key != "time_out":
+      del cfg.terminations[key]
+
+  # Reset every 2 seconds to better showcase flat patch spawning.
+  cfg.episode_length_s = 2.0
+
+  # Replace reset_base event with flat-patch spawning.
+  cfg.events["reset_base"] = EventTermCfg(
+    func=mdp.reset_root_state_from_flat_patches,
+    mode="reset",
+    params={
+      "patch_name": "spawn",
+      "pose_range": {"z": (0.01, 0.05), "yaw": (-3.14, 3.14)},
+    },
+  )
+
+  print("=" * 60)
+  print("Flat Patch Terrain Demo")
+  print("  Toggle group 3 to see flat patch markers (orange spheres)")
+  print("  Press Enter in terminal to reset robot onto a flat patch")
+  print("=" * 60)
+
+  env = ManagerBasedRlEnv(cfg=cfg, device=device)
+  env = RslRlVecEnvWrapper(env)
+
+  class ZeroPolicy:
+    def __call__(self, obs) -> torch.Tensor:
+      del obs
+      return torch.zeros(env.unwrapped.action_space.shape, device=device)
+
+  policy = ZeroPolicy()
+
+  if viewer == "auto":
+    has_display = bool(os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY"))
+    resolved_viewer = "native" if has_display else "viser"
+  else:
+    resolved_viewer = viewer
+
+  if resolved_viewer == "native":
+    NativeMujocoViewer(env, policy).run()
+  elif resolved_viewer == "viser":
+    ViserPlayViewer(env, policy).run()
+  else:
+    raise ValueError(f"Unknown viewer: {viewer}")
+
+  env.close()
+
+
+if __name__ == "__main__":
+  tyro.cli(main, config=mjlab.TYRO_FLAGS)
diff --git a/scripts/demos/raycast_sensor.py b/scripts/demos/raycast_sensor.py
new file mode 100644
index 0000000..de0da68
--- /dev/null
+++ b/scripts/demos/raycast_sensor.py
@@ -0,0 +1,252 @@
+"""Raycast sensor demo.
+
+Run with:
+  uv run mjpython scripts/demos/raycast_sensor.py [--viewer native|viser]  # macOS
+  uv run python scripts/demos/raycast_sensor.py [--viewer native|viser]    # Linux
+
+Examples:
+  # Grid pattern (default)
+  uv run python scripts/demos/raycast_sensor.py --pattern grid
+
+  # Pinhole camera pattern
+  uv run python scripts/demos/raycast_sensor.py --pattern pinhole
+
+  # With yaw alignment (ignores pitch/roll)
+  uv run python scripts/demos/raycast_sensor.py --alignment yaw
+
+If using the native viewer, you can launch in interactive mode with:
+  uv run mjpython scripts/demos/raycast_sensor.py --viewer native --interactive
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Literal
+
+import mujoco
+import numpy as np
+import torch
+import tyro
+
+import mjlab
+import mjlab.terrains as terrain_gen
+from mjlab.entity import EntityCfg
+from mjlab.envs import ManagerBasedRlEnv, ManagerBasedRlEnvCfg
+from mjlab.rl import RslRlVecEnvWrapper
+from mjlab.scene import SceneCfg
+from mjlab.sensor import (
+  GridPatternCfg,
+  ObjRef,
+  PinholeCameraPatternCfg,
+  RayCastSensorCfg,
+)
+from mjlab.terrains.terrain_entity import TerrainEntityCfg
+from mjlab.terrains.terrain_generator import TerrainGeneratorCfg
+from mjlab.utils.torch import configure_torch_backends
+from mjlab.viewer import NativeMujocoViewer, ViserPlayViewer
+
+
+def create_scanner_spec() -> mujoco.MjSpec:
+  spec = mujoco.MjSpec()
+  spec.modelname = "scanner"
+
+  mat = spec.add_material()
+  mat.name = "scanner_mat"
+  mat.rgba[:] = (1.0, 0.5, 0.0, 0.9)
+
+  scanner = spec.worldbody.add_body(mocap=True)
+  scanner.name = "scanner"
+  scanner.pos[:] = (0, 0, 2.0)
+
+  geom = scanner.add_geom()
+  geom.name = "scanner_geom"
+  geom.type = mujoco.mjtGeom.mjGEOM_BOX
+  geom.size[:] = (0.15, 0.15, 0.05)
+  geom.mass = 1.0
+  geom.material = "scanner_mat"
+
+  scanner.add_camera(name="scanner", fovy=58.0, resolution=(16, 12))
+
+  record_cam = scanner.add_camera(name="record_cam")
+  record_cam.pos[:] = (2, 0, 2)
+  record_cam.fovy = 40.0
+  record_cam.mode = mujoco.mjtCamLight.mjCAMLIGHT_TARGETBODY
+  record_cam.targetbody = "scanner"
+
+  return spec
+
+
+def create_env_cfg(
+  pattern: Literal["grid", "pinhole"],
+  alignment: Literal["base", "yaw", "world"],
+) -> ManagerBasedRlEnvCfg:
+  custom_terrain_cfg = TerrainGeneratorCfg(
+    size=(4.0, 4.0),
+    border_width=0.5,
+    num_rows=1,
+    num_cols=4,
+    curriculum=True,
+    sub_terrains={
+      "pyramid_stairs_inv": terrain_gen.BoxInvertedPyramidStairsTerrainCfg(
+        proportion=0.25,
+        step_height_range=(0.1, 0.25),
+        step_width=0.3,
+        platform_width=1.5,
+        border_width=0.25,
+      ),
+      "hf_pyramid_slope_inv": terrain_gen.HfPyramidSlopedTerrainCfg(
+        proportion=0.25,
+        slope_range=(0.6, 1.5),
+        platform_width=1.5,
+        border_width=0.25,
+        inverted=True,
+      ),
+      "random_rough": terrain_gen.HfRandomUniformTerrainCfg(
+        proportion=0.25,
+        noise_range=(0.05, 0.15),
+        noise_step=0.02,
+        border_width=0.25,
+      ),
+      "wave_terrain": terrain_gen.HfWaveTerrainCfg(
+        proportion=0.25,
+        amplitude_range=(0.15, 0.25),
+        num_waves=3,
+        border_width=0.25,
+      ),
+    },
+    add_lights=True,
+  )
+
+  terrain_cfg = TerrainEntityCfg(
+    terrain_type="generator",
+    terrain_generator=custom_terrain_cfg,
+    num_envs=1,
+  )
+
+  scanner_entity_cfg = EntityCfg(
+    spec_fn=create_scanner_spec,
+    init_state=EntityCfg.InitialStateCfg(pos=(0.65, -0.4, 0.5)),
+  )
+
+  if pattern == "grid":
+    pattern_cfg = GridPatternCfg(
+      size=(0.6, 0.6),
+      resolution=0.1,
+      direction=(0.0, 0.0, -1.0),
+    )
+  else:
+    assert pattern == "pinhole"
+    pattern_cfg = PinholeCameraPatternCfg.from_mujoco_camera("scanner/scanner")
+
+  raycast_cfg = RayCastSensorCfg(
+    name="terrain_scan",
+    frame=ObjRef(type="body", name="scanner", entity="scanner"),
+    pattern=pattern_cfg,
+    ray_alignment=alignment,
+    max_distance=5.0,
+    exclude_parent_body=True,
+    debug_vis=True,
+    viz=RayCastSensorCfg.VizCfg(
+      hit_color=(0.0, 1.0, 0.0, 0.9),
+      miss_color=(1.0, 0.0, 0.0, 0.5),
+      show_rays=False,
+      show_normals=True,
+    ),
+  )
+
+  cfg = ManagerBasedRlEnvCfg(
+    decimation=10,
+    scene=SceneCfg(
+      num_envs=1,
+      env_spacing=0.0,
+      extent=2.0,
+      terrain=terrain_cfg,
+      entities={"scanner": scanner_entity_cfg},
+      sensors=(raycast_cfg,),
+    ),
+  )
+
+  cfg.viewer.body_name = "scanner"
+  cfg.viewer.distance = 12.0
+  cfg.viewer.elevation = -25.0
+  cfg.viewer.azimuth = 135.0
+
+  return cfg
+
+
+def main(
+  viewer: str = "auto",
+  interactive: bool = False,
+  pattern: Literal["grid", "pinhole"] = "grid",
+  alignment: Literal["base", "yaw", "world"] = "base",
+) -> None:
+  configure_torch_backends()
+
+  device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+  print("=" * 60)
+  print("Raycast Sensor Demo - 4 Terrain Types")
+  print(f"  Pattern: {pattern}")
+  print(f"  Alignment: {alignment}")
+  print("=" * 60)
+  print()
+
+  env_cfg = create_env_cfg(pattern, alignment)
+  env = ManagerBasedRlEnv(cfg=env_cfg, device=device)
+  env = RslRlVecEnvWrapper(env)
+
+  if viewer == "auto":
+    has_display = bool(os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY"))
+    resolved_viewer = "native" if has_display else "viser"
+  else:
+    resolved_viewer = viewer
+
+  use_auto_scan = (resolved_viewer == "viser") or (not interactive)
+
+  if use_auto_scan:
+
+    class AutoScanPolicy:
+      def __init__(self):
+        self.step_count = 0
+
+      def __call__(self, obs) -> torch.Tensor:
+        del obs
+        t = self.step_count * 0.005
+        y_period = 1000
+        y_normalized = (self.step_count % y_period) / y_period
+        y = -8.0 + 16.0 * y_normalized
+        x = 1.5 * np.sin(2 * np.pi * t * 0.3)
+        z = 1.0
+        env.unwrapped.sim.data.mocap_pos[0, 0, :] = torch.tensor(
+          [x, y, z], device=device, dtype=torch.float32
+        )
+        env.unwrapped.sim.data.mocap_quat[0, 0, :] = torch.tensor(
+          [1, 0, 0, 0], device=device, dtype=torch.float32
+        )
+        self.step_count += 1
+        return torch.zeros(env.unwrapped.action_space.shape, device=device)
+
+    policy = AutoScanPolicy()
+  else:
+
+    class PolicyZero:
+      def __call__(self, obs) -> torch.Tensor:
+        del obs
+        return torch.zeros(env.unwrapped.action_space.shape, device=device)
+
+    policy = PolicyZero()
+
+  if resolved_viewer == "native":
+    print("Launching native viewer...")
+    NativeMujocoViewer(env, policy).run()
+  elif resolved_viewer == "viser":
+    print("Launching viser viewer...")
+    ViserPlayViewer(env, policy).run()
+  else:
+    raise ValueError(f"Unknown viewer: {viewer}")
+
+  env.close()
+
+
+if __name__ == "__main__":
+  tyro.cli(main, config=mjlab.TYRO_FLAGS)
diff --git a/scripts/fix_mjpython_macos.sh b/scripts/fix_mjpython_macos.sh
new file mode 100644
index 0000000..51ef89a
--- /dev/null
+++ b/scripts/fix_mjpython_macos.sh
@@ -0,0 +1,36 @@
+#!/bin/bash
+# Fix mjpython on macOS by creating a symlink to libpython.
+# This is needed because mjpython expects libpython in .venv/lib/
+
+set -e
+
+VENV_DIR=".venv"
+
+if [[ "$(uname)" != "Darwin" ]]; then
+    echo "This script is only needed on macOS."
+    exit 0
+fi
+
+if [[ ! -d "$VENV_DIR" ]]; then
+    echo "Error: .venv directory not found. Run 'uv sync' first."
+    exit 1
+fi
+
+# Get Python version and prefix from the venv.
+PYTHON_VERSION=$("$VENV_DIR/bin/python" -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')")
+PYTHON_PREFIX=$("$VENV_DIR/bin/python" -c "import sys; print(sys.base_prefix)")
+DYLIB_NAME="libpython${PYTHON_VERSION}.dylib"
+
+# Find the dylib in the Python installation.
+DYLIB_PATH="$PYTHON_PREFIX/lib/$DYLIB_NAME"
+
+if [[ ! -f "$DYLIB_PATH" ]]; then
+    echo "Error: Could not find $DYLIB_PATH"
+    exit 1
+fi
+
+# Create the symlink.
+mkdir -p "$VENV_DIR/lib"
+ln -sf "$DYLIB_PATH" "$VENV_DIR/lib/$DYLIB_NAME"
+
+echo "Created symlink: $VENV_DIR/lib/$DYLIB_NAME -> $DYLIB_PATH"
diff --git a/scripts/run_docker.sh b/scripts/run_docker.sh
new file mode 100644
index 0000000..e682f1c
--- /dev/null
+++ b/scripts/run_docker.sh
@@ -0,0 +1,37 @@
+#!/usr/bin/env sh
+#
+# Injects useful arguments for running mjlab in docker.
+# See docs/source/installation.rst for usage.
+#
+# Patterned after the uv-in-docker example:
+# https://github.com/astral-sh/uv-docker-example/blob/5748835918ec293d547bbe0e42df34e140aca1eb/run.sh
+#
+# Key arguments:
+#   --rm                Remove the container after exiting
+#   --runtime=nvidia    Use NVIDIA Container runtime to give GPU access
+#   --gpus all          Expose all GPUs by default
+#   -v .:/app           Mount current directory to /app (code changes don't require rebuild)
+#   -v /app/.venv       Mount venv separately (keeps developer's environment out of container)
+#   -p 8080:8080        Publish port 8080 for viewing mjlab web interface on the host
+#   -it (conditional)   Launch in interactive mode if running in a terminal
+#                       (Note: if running training, there's a blocking wandb prompt before training begins)
+#   docker build        Build and launch the image (tag matches the Makefile)
+#   "$@"                Forward all arguments to the docker image
+
+
+if [ -t 1 ]; then
+    INTERACTIVE="-it"
+else
+    INTERACTIVE=""
+fi
+
+docker run \
+    --rm \
+    --runtime=nvidia \
+    --gpus all \
+    --volume .:/app \
+    --volume /app/.venv \
+    --publish 8080:8080 \
+    $INTERACTIVE \
+    $(docker build -qt mjlab .) \
+    "$@"
diff --git a/scripts/tools/render_terrain_gallery.py b/scripts/tools/render_terrain_gallery.py
new file mode 100644
index 0000000..5419878
--- /dev/null
+++ b/scripts/tools/render_terrain_gallery.py
@@ -0,0 +1,305 @@
+"""Render images of each sub-terrain type for documentation.
+
+Generates one PNG per terrain type at a fixed difficulty level.
+Images are saved to docs/source/_static/terrains/.
+
+Run with:
+  uv run python scripts/tools/render_terrain_gallery.py
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import mujoco
+import numpy as np
+from PIL import Image
+
+import mjlab.terrains as terrain_gen
+from mjlab.terrains import TerrainEntity, TerrainEntityCfg
+from mjlab.terrains.terrain_generator import TerrainGeneratorCfg
+from mjlab.utils import spec_config as spec_cfg
+
+OUTPUT_DIR = Path("docs/source/_static/terrains")
+WIDTH = 1080
+HEIGHT = 1080
+DIFFICULTY = 0.85
+PATCH_SIZE = (8.0, 8.0)
+
+
+# Each entry: (filename, SubTerrainCfg instance).
+TERRAIN_TYPES: list[tuple[str, terrain_gen.SubTerrainCfg]] = [
+  # Primitive terrains.
+  (
+    "box_flat",
+    terrain_gen.BoxFlatTerrainCfg(proportion=1.0),
+  ),
+  (
+    "box_pyramid_stairs",
+    terrain_gen.BoxPyramidStairsTerrainCfg(
+      proportion=1.0,
+      step_height_range=(0.0, 0.2),
+      step_width=0.3,
+      platform_width=3.0,
+      border_width=1.0,
+    ),
+  ),
+  (
+    "box_inverted_pyramid_stairs",
+    terrain_gen.BoxInvertedPyramidStairsTerrainCfg(
+      proportion=1.0,
+      step_height_range=(0.0, 0.2),
+      step_width=0.3,
+      platform_width=3.0,
+      border_width=1.0,
+    ),
+  ),
+  (
+    "box_random_stairs",
+    terrain_gen.BoxRandomStairsTerrainCfg(
+      proportion=1.0,
+      step_width=0.8,
+      step_height_range=(0.1, 0.3),
+      platform_width=1.0,
+      border_width=0.25,
+    ),
+  ),
+  (
+    "box_open_stairs",
+    terrain_gen.BoxOpenStairsTerrainCfg(
+      proportion=1.0,
+      step_height_range=(0.1, 0.2),
+      step_width_range=(0.4, 0.8),
+      platform_width=1.0,
+      border_width=0.25,
+    ),
+  ),
+  (
+    "box_random_grid",
+    terrain_gen.BoxRandomGridTerrainCfg(
+      proportion=1.0,
+      grid_width=0.4,
+      grid_height_range=(0.0, 0.3),
+      platform_width=1.0,
+    ),
+  ),
+  (
+    "box_random_spread",
+    terrain_gen.BoxRandomSpreadTerrainCfg(
+      proportion=1.0,
+      num_boxes=80,
+      box_width_range=(0.1, 1.0),
+      box_length_range=(0.1, 2.0),
+      box_height_range=(0.05, 0.3),
+      platform_width=1.0,
+      border_width=0.25,
+    ),
+  ),
+  (
+    "box_stepping_stones",
+    terrain_gen.BoxSteppingStonesTerrainCfg(
+      proportion=1.0,
+      stone_size_range=(0.4, 0.8),
+      stone_distance_range=(0.2, 0.5),
+      stone_height=0.2,
+      stone_height_variation=0.1,
+      stone_size_variation=0.2,
+      displacement_range=0.1,
+      floor_depth=2.0,
+      platform_width=1.0,
+      border_width=0.25,
+    ),
+  ),
+  (
+    "box_narrow_beams",
+    terrain_gen.BoxNarrowBeamsTerrainCfg(
+      proportion=1.0,
+      num_beams=12,
+      beam_width_range=(0.2, 0.8),
+      beam_height=0.2,
+      spacing=0.8,
+      platform_width=1.0,
+      border_width=0.25,
+      floor_depth=2.0,
+    ),
+  ),
+  (
+    "box_tilted_grid",
+    terrain_gen.BoxTiltedGridTerrainCfg(
+      proportion=1.0,
+      grid_width=1.0,
+      tilt_range_deg=20.0,
+      height_range=0.3,
+      platform_width=1.0,
+      border_width=0.25,
+      floor_depth=2.0,
+    ),
+  ),
+  (
+    "box_nested_rings",
+    terrain_gen.BoxNestedRingsTerrainCfg(
+      proportion=1.0,
+      num_rings=8,
+      ring_width_range=(0.3, 0.6),
+      gap_range=(0.1, 0.4),
+      height_range=(0.1, 0.4),
+      platform_width=1.0,
+      border_width=0.25,
+      floor_depth=2.0,
+    ),
+  ),
+  # Heightfield terrains.
+  (
+    "hf_pyramid_slope",
+    terrain_gen.HfPyramidSlopedTerrainCfg(
+      proportion=1.0,
+      slope_range=(0.0, 0.7),
+      platform_width=2.0,
+      border_width=0.25,
+    ),
+  ),
+  (
+    "hf_random_uniform",
+    terrain_gen.HfRandomUniformTerrainCfg(
+      proportion=1.0,
+      noise_range=(0.02, 0.10),
+      noise_step=0.02,
+      border_width=0.25,
+    ),
+  ),
+  (
+    "hf_wave",
+    terrain_gen.HfWaveTerrainCfg(
+      proportion=1.0,
+      amplitude_range=(0.1, 0.5),
+      num_waves=6,
+      border_width=0.25,
+    ),
+  ),
+  (
+    "hf_discrete_obstacles",
+    terrain_gen.HfDiscreteObstaclesTerrainCfg(
+      proportion=1.0,
+      obstacle_width_range=(0.3, 1.0),
+      obstacle_height_range=(0.05, 0.3),
+      num_obstacles=40,
+      border_width=0.25,
+    ),
+  ),
+  (
+    "hf_perlin_noise",
+    terrain_gen.HfPerlinNoiseTerrainCfg(
+      proportion=1.0,
+      height_range=(0.0, 1.0),
+      octaves=4,
+      persistence=0.3,
+      lacunarity=2.0,
+      scale=10.0,
+      horizontal_scale=0.1,
+      border_width=0.50,
+    ),
+  ),
+]
+
+
+CAMERA_DISTANCE = 8.0
+CAMERA_ELEVATION_DEG = 50.0  # Degrees from horizontal (90 = top-down).
+CAMERA_AZIMUTH_DEG = 135.0  # Rotation around the vertical axis.
+FOV_PADDING = 1.1
+
+
+def render_terrain(
+  name: str,
+  sub_terrain_cfg: terrain_gen.SubTerrainCfg,
+) -> np.ndarray:
+  """Generate and render a single terrain type, return RGB array."""
+  terrain_cfg = TerrainEntityCfg(
+    terrain_type="generator",
+    terrain_generator=TerrainGeneratorCfg(
+      seed=42,
+      size=PATCH_SIZE,
+      num_rows=1,
+      num_cols=1,
+      border_width=0.0,
+      curriculum=False,
+      difficulty_range=(DIFFICULTY, DIFFICULTY),
+      color_scheme="height",
+      sub_terrains={name: sub_terrain_cfg},
+    ),
+    lights=(
+      spec_cfg.LightCfg(
+        name="sun",
+        type="directional",
+        dir=(-0.15, -0.15, -0.97),
+        castshadow=True,
+      ),
+    ),
+  )
+  terrain = TerrainEntity(terrain_cfg, device="cpu")
+
+  # Place camera at an isometric-ish angle to reveal 3D structure.
+  elev = np.deg2rad(CAMERA_ELEVATION_DEG)
+  azim = np.deg2rad(CAMERA_AZIMUTH_DEG)
+  cam_pos = CAMERA_DISTANCE * np.array(
+    [
+      np.cos(elev) * np.cos(azim),
+      np.cos(elev) * np.sin(azim),
+      np.sin(elev),
+    ]
+  )
+
+  # Look at a point slightly below the origin so the terrain centers
+  # in the frame instead of sitting in the bottom half.
+  lookat = np.array([0.0, 0.0, -2.0])
+  forward = lookat - cam_pos
+  forward /= np.linalg.norm(forward)
+  # MuJoCo camera convention: -z is forward, y is up.
+  up = np.array([0.0, 0.0, 1.0])
+  right = np.cross(forward, up)
+  right /= np.linalg.norm(right)
+  cam_up = np.cross(right, forward)
+
+  # Build rotation matrix (columns: right, cam_up, -forward).
+  rot = np.column_stack([right, cam_up, -forward])
+  # Convert to quaternion (wxyz).
+  from scipy.spatial.transform import Rotation
+
+  quat_xyzw = Rotation.from_matrix(rot).as_quat()
+  quat_wxyz = [quat_xyzw[3], quat_xyzw[0], quat_xyzw[1], quat_xyzw[2]]
+
+  # FOV sized to fit the patch diagonal from this viewing angle.
+  apparent_size = max(PATCH_SIZE) * FOV_PADDING
+  fovy_rad = 2 * np.arctan2(apparent_size / 2, CAMERA_DISTANCE)
+
+  terrain.spec.worldbody.add_camera(
+    name="gallery",
+    pos=cam_pos.tolist(),
+    quat=quat_wxyz,
+    fovy=np.rad2deg(fovy_rad),
+  )
+
+  model = terrain.spec.compile()
+  model.vis.global_.offheight = HEIGHT
+  model.vis.global_.offwidth = WIDTH
+  data = mujoco.MjData(model)
+  mujoco.mj_forward(model, data)
+
+  with mujoco.Renderer(model, height=HEIGHT, width=WIDTH) as renderer:
+    renderer.update_scene(data, camera="gallery")
+    return renderer.render()
+
+
+def main() -> None:
+  OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+  for filename, sub_cfg in TERRAIN_TYPES:
+    print(f"Rendering {filename}...")
+    img = render_terrain(filename, sub_cfg)
+    Image.fromarray(img).save(OUTPUT_DIR / f"{filename}.png")
+    print(f"  Saved {OUTPUT_DIR / filename}.png")
+
+  print(f"\nDone. {len(TERRAIN_TYPES)} images saved to {OUTPUT_DIR}/")
+
+
+if __name__ == "__main__":
+  main()
diff --git a/scripts/tools/terrain_explorer.py b/scripts/tools/terrain_explorer.py
new file mode 100644
index 0000000..f3b8cfe
--- /dev/null
+++ b/scripts/tools/terrain_explorer.py
@@ -0,0 +1,115 @@
+"""Interactive single-patch terrain explorer (Viser + MuJoCo MjSpec).
+
+Run with:
+  uv run python scripts/tools/terrain_explorer.py
+  uv run python scripts/tools/terrain_explorer.py --port 8081
+
+Then open the printed URL (default http://localhost:8080).
+"""
+
+from __future__ import annotations
+
+import argparse
+import time
+
+import mujoco
+import numpy as np
+import viser
+from mjviser.conversions import merge_geoms
+
+from mjlab.terrains.config import ALL_TERRAIN_PRESETS
+from mjlab.terrains.terrain_generator import TerrainGenerator, TerrainGeneratorCfg
+
+PATCH_SIZE = (8.0, 8.0)
+
+
+# Per-preset overrides applied when building in the explorer (e.g. to surface
+# difficulty-driven behavior that is off by default).
+_PRESET_OVERRIDES: dict[str, dict] = {
+  "random_rough": {"scale_with_difficulty": True},
+}
+
+
+def _build_terrain_mesh(preset_name: str, difficulty: float, seed: int):
+  """Generate a single terrain patch and return a merged trimesh (or raise)."""
+  preset_fn = ALL_TERRAIN_PRESETS[preset_name]
+  overrides = _PRESET_OVERRIDES.get(preset_name, {})
+  generator_cfg = TerrainGeneratorCfg(
+    seed=seed,
+    size=PATCH_SIZE,
+    num_rows=1,
+    num_cols=1,
+    border_width=0.0,
+    curriculum=False,
+    # A degenerate range pins the single patch to exactly this difficulty.
+    difficulty_range=(difficulty, difficulty),
+    color_scheme="height",
+    sub_terrains={preset_name: preset_fn(proportion=1.0, **overrides)},
+  )
+  generator = TerrainGenerator(generator_cfg)
+  spec = mujoco.MjSpec()
+  generator.compile(spec)
+  model = spec.compile()
+
+  terrain_body_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_BODY, "terrain")
+  geom_ids = [i for i in range(model.ngeom) if model.geom_bodyid[i] == terrain_body_id]
+  return merge_geoms(model, geom_ids)
+
+
+def main() -> None:
+  parser = argparse.ArgumentParser(description=__doc__)
+  parser.add_argument(
+    "--port", type=int, default=8080, help="Port for the viser server."
+  )
+  args = parser.parse_args()
+
+  server = viser.ViserServer(port=args.port)
+  preset_names = sorted(ALL_TERRAIN_PRESETS)
+
+  terrain_dropdown = server.gui.add_dropdown(
+    "Terrain", options=preset_names, initial_value=preset_names[0]
+  )
+  difficulty_slider = server.gui.add_slider(
+    "Difficulty", min=0.0, max=1.0, step=0.01, initial_value=0.0
+  )
+  seed_input = server.gui.add_number("Seed", initial_value=42, step=1)
+  status = server.gui.add_markdown("**Status:** ready")
+
+  handle: viser.SceneNodeHandle | None = None
+
+  def update() -> None:
+    nonlocal handle
+    name = terrain_dropdown.value
+    difficulty = float(difficulty_slider.value)
+    seed = int(seed_input.value)
+    status.content = f"**Status:** building `{name}` at difficulty {difficulty:.2f}..."
+    try:
+      mesh = _build_terrain_mesh(name, difficulty, seed)
+    except Exception as e:  # noqa: BLE001 - surface any generation failure in the UI.
+      status.content = f"**Error:** {type(e).__name__}: {e}"
+      print(f"Failed to build {name} at difficulty {difficulty}: {e}")
+      return
+    if handle is not None:
+      handle.remove()
+    handle = server.scene.add_mesh_trimesh("/terrain", mesh)
+    status.content = (
+      f"**Loaded** `{name}` at difficulty {difficulty:.2f} ({len(mesh.faces):,} faces)"
+    )
+
+  terrain_dropdown.on_update(lambda _: update())
+  difficulty_slider.on_update(lambda _: update())
+  seed_input.on_update(lambda _: update())
+
+  # Top-down-ish initial camera.
+  @server.on_client_connect
+  def _(client: viser.ClientHandle) -> None:
+    client.camera.position = np.array([10.0, 10.0, 8.0])
+    client.camera.look_at = np.array([0.0, 0.0, 0.0])
+
+  update()
+  while True:
+    time.sleep(1.0)
+
+
+if __name__ == "__main__":
+  main()
diff --git a/src/mjlab/__init__.py b/src/mjlab/__init__.py
new file mode 100644
index 0000000..462b3f0
--- /dev/null
+++ b/src/mjlab/__init__.py
@@ -0,0 +1,75 @@
+import os
+import sys
+
+# Default to EGL for GPU-accelerated offscreen rendering on Linux. Must be set
+# before any mujoco import: mujoco's gl_context module captures MUJOCO_GL once
+# at load time. Override with e.g. MUJOCO_GL=osmesa on clusters without EGL.
+# Linux-only because mujoco's gl_context rejects "egl" on macOS/Windows and
+# raises at import. On those platforms we leave MUJOCO_GL alone so mujoco
+# defaults to GLFW.
+if sys.platform.startswith("linux"):
+  os.environ.setdefault("MUJOCO_GL", "egl")
+
+import traceback
+from importlib.metadata import entry_points
+from pathlib import Path
+
+import tyro
+import warp as wp
+
+MJLAB_SRC_PATH: Path = Path(__file__).parent
+
+TYRO_FLAGS = (
+  # Don't let users switch between types in unions. This produces a simpler CLI
+  # with flatter helptext, at the cost of some flexibility. Type changes can
+  # just be done in code.
+  tyro.conf.AvoidSubcommands,
+  # Disable automatic flag conversion (e.g., use `--flag False` instead of
+  # `--no-flag` for booleans).
+  tyro.conf.FlagConversionOff,
+  # Use Python syntax for collections: --tuple (1,2,3) instead of --tuple 1 2 3.
+  # Helps with wandb sweep compatibility: https://brentyi.github.io/tyro/wandb_sweeps/
+  tyro.conf.UsePythonSyntaxForLiteralCollections,
+)
+
+
+def _configure_warp() -> None:
+  """Configure Warp globally for mjlab."""
+  wp.config.enable_backward = False
+
+  # Keep warp verbose by default to show kernel compilation progress.
+  # Override with MJLAB_WARP_QUIET=1 environment variable if needed.
+  quiet = os.environ.get("MJLAB_WARP_QUIET", "0").lower() in ("1", "true", "yes")
+  wp.config.quiet = quiet
+
+
+def _import_registered_packages() -> None:
+  """Auto-discover and import packages registered via entry points.
+
+  Looks for packages registered under the 'mjlab.tasks' entry point group.
+  Each discovered package is imported, which allows it to register custom
+  environments with gymnasium.
+  """
+  mjlab_tasks = entry_points().select(group="mjlab.tasks")
+  for entry_point in mjlab_tasks:
+    try:
+      entry_point.load()
+    except Exception:
+      print(
+        f"[WARN] Failed to load task package '{entry_point.name}' ({entry_point.value}):",
+        file=sys.stderr,
+      )
+      traceback.print_exc(file=sys.stderr)
+
+
+def _configure_mediapy() -> None:
+  """Point mediapy at the bundled imageio-ffmpeg binary."""
+  import imageio_ffmpeg
+  import mediapy
+
+  mediapy.set_ffmpeg(imageio_ffmpeg.get_ffmpeg_exe())
+
+
+_configure_warp()
+_configure_mediapy()
+_import_registered_packages()
diff --git a/src/mjlab/actuator/__init__.py b/src/mjlab/actuator/__init__.py
new file mode 100644
index 0000000..e61cea9
--- /dev/null
+++ b/src/mjlab/actuator/__init__.py
@@ -0,0 +1,63 @@
+"""Actuator implementations for mjlab."""
+
+from mjlab.actuator.actuator import Actuator as Actuator
+from mjlab.actuator.actuator import ActuatorCfg as ActuatorCfg
+from mjlab.actuator.actuator import ActuatorCmd as ActuatorCmd
+from mjlab.actuator.actuator import CommandField as CommandField
+from mjlab.actuator.builtin_actuator import (
+  BuiltinDcMotorActuator as BuiltinDcMotorActuator,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinDcMotorActuatorCfg as BuiltinDcMotorActuatorCfg,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinMotorActuator as BuiltinMotorActuator,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinMotorActuatorCfg as BuiltinMotorActuatorCfg,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinMuscleActuator as BuiltinMuscleActuator,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinMuscleActuatorCfg as BuiltinMuscleActuatorCfg,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinPdActuator as BuiltinPdActuator,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinPdActuatorCfg as BuiltinPdActuatorCfg,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinPositionActuator as BuiltinPositionActuator,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinPositionActuatorCfg as BuiltinPositionActuatorCfg,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinVelocityActuator as BuiltinVelocityActuator,
+)
+from mjlab.actuator.builtin_actuator import (
+  BuiltinVelocityActuatorCfg as BuiltinVelocityActuatorCfg,
+)
+from mjlab.actuator.builtin_actuator import (
+  DcMotorDatasheetParams as DcMotorDatasheetParams,
+)
+from mjlab.actuator.builtin_actuator import (
+  DcMotorInputMode as DcMotorInputMode,
+)
+from mjlab.actuator.builtin_actuator import (
+  DcMotorPhysicalParams as DcMotorPhysicalParams,
+)
+from mjlab.actuator.builtin_group import BuiltinActuatorGroup as BuiltinActuatorGroup
+from mjlab.actuator.dc_actuator import DcMotorActuator as DcMotorActuator
+from mjlab.actuator.dc_actuator import DcMotorActuatorCfg as DcMotorActuatorCfg
+from mjlab.actuator.fused_group import FusedActuatorGroup as FusedActuatorGroup
+from mjlab.actuator.learned_actuator import LearnedMlpActuator as LearnedMlpActuator
+from mjlab.actuator.learned_actuator import (
+  LearnedMlpActuatorCfg as LearnedMlpActuatorCfg,
+)
+from mjlab.actuator.pd_actuator import IdealPdActuator as IdealPdActuator
+from mjlab.actuator.pd_actuator import IdealPdActuatorCfg as IdealPdActuatorCfg
+from mjlab.actuator.xml_actuator import XmlActuator as XmlActuator
+from mjlab.actuator.xml_actuator import XmlActuatorCfg as XmlActuatorCfg
diff --git a/src/mjlab/actuator/actuator.py b/src/mjlab/actuator/actuator.py
new file mode 100644
index 0000000..756d450
--- /dev/null
+++ b/src/mjlab/actuator/actuator.py
@@ -0,0 +1,436 @@
+"""Base actuator interface."""
+
+from __future__ import annotations
+
+import dataclasses
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, ClassVar, Generic, Literal, TypeVar
+
+import mujoco
+import mujoco_warp as mjwarp
+import torch
+
+from mjlab.utils.buffers import DelayBuffer
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+  from mjlab.entity.data import EntityData
+
+ActuatorCfgT = TypeVar("ActuatorCfgT", bound="ActuatorCfg")
+
+CommandField = Literal["position", "velocity", "effort"]
+
+
+class TransmissionType(str, Enum):
+  """Transmission types for actuators."""
+
+  JOINT = "joint"
+  TENDON = "tendon"
+  SITE = "site"
+
+
+@dataclass(kw_only=True)
+class ActuatorCfg(ABC):
+  target_names_expr: tuple[str, ...]
+  """Targets that are part of this actuator group.
+
+  Can be a tuple of names or tuple of regex expressions. Interpreted based on
+  transmission_type.
+  """
+
+  transmission_type: TransmissionType = TransmissionType.JOINT
+  """Transmission type. Defaults to JOINT."""
+
+  armature: float | None = None
+  """Reflected rotor inertia. None preserves the XML value."""
+
+  frictionloss: float | None = None
+  """Friction loss force limit. None preserves the XML value.
+
+  Applies a constant friction force opposing motion, independent of load or velocity.
+  Also known as dry friction or load-independent friction.
+  """
+
+  viscous_damping: float | None = None
+  """Passive viscous damping coefficient. None preserves the XML value.
+
+  Produces a dissipative force f(v) = -b·v proportional to velocity. Always present
+  regardless of actuator activity. Unlike ``damping`` (the PD derivative gain kv, which
+  is active control), this is a passive property.
+
+  Maps to ``<joint damping>`` for JOINT transmission and ``<tendon damping>``
+  for TENDON transmission. Ignored for SITE.
+  """
+
+  delay_min_lag: int = 0
+  """Minimum command delay in physics timesteps.
+
+  Each step, a lag is sampled uniformly from [min, max]. The command target arrives
+  that many steps late at the actuator's control law. Models communication and bus
+  latency between the policy and the motor (as opposed to observation delay, which
+  models sensor pipeline latency).
+  """
+
+  delay_max_lag: int = 0
+  """Maximum command delay in physics timesteps. Set > 0 to enable delay."""
+
+  delay_hold_prob: float = 0.0
+  """Probability of keeping the current lag instead of resampling."""
+
+  delay_update_period: int = 0
+  """How often to resample the lag, in physics timesteps (0 = every step)."""
+
+  delay_per_env_phase: bool = True
+  """Stagger lag resampling across environments so they don't all update
+  on the same step."""
+
+  def __post_init__(self) -> None:
+    if self.armature is not None:
+      assert self.armature >= 0.0, "armature must be non-negative."
+    if self.frictionloss is not None:
+      assert self.frictionloss >= 0.0, "frictionloss must be non-negative."
+    if self.viscous_damping is not None:
+      assert self.viscous_damping >= 0.0, "viscous_damping must be non-negative."
+    if self.transmission_type == TransmissionType.SITE:
+      if (
+        (self.armature is not None and self.armature > 0.0)
+        or (self.frictionloss is not None and self.frictionloss > 0.0)
+        or (self.viscous_damping is not None and self.viscous_damping > 0.0)
+      ):
+        raise ValueError(
+          f"{self.__class__.__name__}: armature, frictionloss, and viscous_damping are "
+          "not supported for SITE transmission type."
+        )
+    assert self.delay_min_lag >= 0, "delay_min_lag must be non-negative."
+    assert self.delay_max_lag >= 0, "delay_max_lag must be non-negative."
+    assert self.delay_min_lag <= self.delay_max_lag, (
+      "delay_min_lag must be <= delay_max_lag."
+    )
+    assert 0.0 <= self.delay_hold_prob <= 1.0, "delay_hold_prob must be in [0, 1]."
+    assert self.delay_update_period >= 0, "delay_update_period must be non-negative."
+
+  @abstractmethod
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> Actuator:
+    """Build actuator instance.
+
+    Args:
+      entity: Entity this actuator belongs to.
+      target_ids: Local target indices (for indexing entity arrays).
+      target_names: Target names corresponding to target_ids.
+
+    Returns:
+      Actuator instance.
+    """
+    raise NotImplementedError
+
+
+@dataclass
+class ActuatorCmd:
+  """High-level actuator command with targets and current state.
+
+  Passed to actuator's `compute()` method to generate low-level control signals.
+  All tensors have shape (num_envs, num_targets).
+  """
+
+  position_target: torch.Tensor
+  """Desired positions (joint positions, tendon lengths, or site positions)."""
+  velocity_target: torch.Tensor
+  """Desired velocities (joint velocities, tendon velocities, or site velocities)."""
+  effort_target: torch.Tensor
+  """Feedforward effort (torques or forces)."""
+  pos: torch.Tensor
+  """Current positions (joint positions, tendon lengths, or site positions)."""
+  vel: torch.Tensor
+  """Current velocities (joint velocities, tendon velocities, or site velocities)."""
+
+
+def delay_command(
+  buffer: DelayBuffer,
+  position_target: torch.Tensor,
+  velocity_target: torch.Tensor,
+  effort_target: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+  """Delay the three command-target fields through one shared channel.
+
+  Every target the policy issues (position, velocity, effort) travels the same
+  command bus and incurs the same latency, so they are stacked and delayed
+  together by a single DelayBuffer. Feedback (pos, vel) is never delayed. Shared
+  by Actuator.apply_delay and the fused group so the command-delay semantics
+  live in exactly one place.
+
+  Args:
+    buffer: The delay buffer to append to and read the delayed command from.
+    position_target: Position targets, shape (num_envs, num_targets).
+    velocity_target: Velocity targets, shape (num_envs, num_targets).
+    effort_target: Feedforward effort targets, shape (num_envs, num_targets).
+
+  Returns:
+    The delayed (position_target, velocity_target, effort_target) tuple.
+  """
+  stacked = torch.stack((position_target, velocity_target, effort_target), dim=-1)
+  buffer.append(stacked)
+  delayed = buffer.compute()
+  return delayed[..., 0], delayed[..., 1], delayed[..., 2]
+
+
+class Actuator(ABC, Generic[ActuatorCfgT]):
+  """Base actuator interface."""
+
+  # Fusion contract. An actuator whose control output is a stateless function of
+  # per-target parameters and the command implements control_law over the
+  # parameter tensors named in param_names, and applies it through the shared
+  # compute (see IdealPdActuator). Such actuators are fused automatically (see
+  # mjlab.actuator.fused_group). Actuators with a custom compute (built-ins, XML,
+  # learned networks) are not fused; they need no opt-out flag, since overriding
+  # compute is itself the signal.
+  param_names: ClassVar[tuple[str, ...]] = ()
+
+  @staticmethod
+  def control_law(params: dict[str, torch.Tensor], cmd: ActuatorCmd) -> torch.Tensor:
+    """Stateless control law over per-target parameters.
+
+    params maps each name in param_names to its tensor of shape
+    (num_envs, num_targets); for a fused group these are the concatenated
+    tensors. Returns the control signal of the same trailing shape. Implemented
+    by stateless-law actuator types.
+    """
+    raise NotImplementedError
+
+  def __init__(
+    self,
+    cfg: ActuatorCfgT,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    self.cfg = cfg
+    self.entity = entity
+    self._target_ids_list = target_ids
+    self._target_names = target_names
+    self._target_ids: torch.Tensor | None = None
+    self._ctrl_ids: torch.Tensor | None = None
+    self._global_ctrl_ids: torch.Tensor | None = None
+    self._mjs_actuators: list[mujoco.MjsActuator] = []
+    self._site_zeros: torch.Tensor | None = None
+    self._delay_buffer: DelayBuffer | None = None
+
+  @property
+  def has_delay(self) -> bool:
+    """Whether this actuator has delay configured."""
+    return self.cfg.delay_max_lag > 0
+
+  @property
+  def target_ids(self) -> torch.Tensor:
+    """Local indices of targets controlled by this actuator."""
+    assert self._target_ids is not None
+    return self._target_ids
+
+  @property
+  def target_names(self) -> list[str]:
+    """Names of targets controlled by this actuator."""
+    return self._target_names
+
+  @property
+  def transmission_type(self) -> TransmissionType:
+    """Transmission type of this actuator."""
+    return self.cfg.transmission_type
+
+  @property
+  def ctrl_ids(self) -> torch.Tensor:
+    """Local indices of control inputs within the entity."""
+    assert self._ctrl_ids is not None
+    return self._ctrl_ids
+
+  @property
+  def global_ctrl_ids(self) -> torch.Tensor:
+    """Global indices of control inputs in the MuJoCo model."""
+    assert self._global_ctrl_ids is not None
+    return self._global_ctrl_ids
+
+  @abstractmethod
+  def edit_spec(self, spec: mujoco.MjSpec, target_names: list[str]) -> None:
+    """Edit the MjSpec to add actuators.
+
+    This is called during entity construction, before the model is compiled.
+
+    Args:
+      spec: The entity's MjSpec to edit.
+      target_names: Names of targets (joints, tendons, or sites) as they
+        appear in the spec. When the entity's ``spec_fn`` uses internal
+        ``MjSpec.attach(prefix=...)``, these will include the prefix
+        (e.g., ``"left/elbow"`` rather than ``"elbow"``).
+    """
+    raise NotImplementedError
+
+  def initialize(
+    self,
+    mj_model: mujoco.MjModel,
+    model: mjwarp.Model,
+    data: mjwarp.Data,
+    device: str,
+  ) -> None:
+    """Initialize the actuator after model compilation.
+
+    This is called after the MjSpec is compiled into an MjModel.
+
+    Args:
+      mj_model: The compiled MuJoCo model.
+      model: The compiled mjwarp model.
+      data: The mjwarp data arrays.
+      device: Device for tensor operations (e.g., "cuda", "cpu").
+    """
+    del mj_model, model  # Unused.
+    self._target_ids = torch.tensor(
+      self._target_ids_list, dtype=torch.long, device=device
+    )
+    global_ctrl_ids_list = [act.id for act in self._mjs_actuators]
+    self._global_ctrl_ids = torch.tensor(
+      global_ctrl_ids_list, dtype=torch.long, device=device
+    )
+    entity_ctrl_ids = self.entity.indexing.ctrl_ids
+    global_to_local = {gid.item(): i for i, gid in enumerate(entity_ctrl_ids)}
+    self._ctrl_ids = torch.tensor(
+      [global_to_local[gid] for gid in global_ctrl_ids_list],
+      dtype=torch.long,
+      device=device,
+    )
+
+    # Pre-allocate zeros for SITE transmission type to avoid repeated allocations.
+    if self.transmission_type == TransmissionType.SITE:
+      nenvs = data.nworld
+      ntargets = len(self._target_ids_list)
+      self._site_zeros = torch.zeros((nenvs, ntargets), device=device)
+
+    self._init_delay_buffer(data.nworld, device)
+
+  def _init_delay_buffer(self, num_envs: int, device: str) -> None:
+    """Create delay buffer. Called during initialize()."""
+    if not self.has_delay:
+      return
+    self._delay_buffer = DelayBuffer(
+      min_lag=self.cfg.delay_min_lag,
+      max_lag=self.cfg.delay_max_lag,
+      batch_size=num_envs,
+      device=device,
+      hold_prob=self.cfg.delay_hold_prob,
+      update_period=self.cfg.delay_update_period,
+      per_env_phase=self.cfg.delay_per_env_phase,
+    )
+
+  def apply_delay(self, cmd: ActuatorCmd) -> ActuatorCmd:
+    """Delay all command targets with one shared lag. No-op without delay.
+
+    Every target the policy issues (position, velocity, effort) travels the same
+    command channel and experiences the same latency, so they are stacked and
+    delayed together. Feedback fields (``pos``, ``vel``) are never delayed.
+    """
+    if self._delay_buffer is None:
+      return cmd
+    position_target, velocity_target, effort_target = delay_command(
+      self._delay_buffer,
+      cmd.position_target,
+      cmd.velocity_target,
+      cmd.effort_target,
+    )
+    return dataclasses.replace(
+      cmd,
+      position_target=position_target,
+      velocity_target=velocity_target,
+      effort_target=effort_target,
+    )
+
+  def set_lags(
+    self,
+    lags: torch.Tensor,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set delay lag values for specified environments.
+
+    Built-in actuators with the same delay config share a fused delay
+    buffer for performance. Calling ``set_lags`` on any one of them
+    affects the entire fused group.
+
+    Args:
+      lags: Lag values in physics timesteps. Shape: (num_env_ids,) or scalar.
+      env_ids: Environment indices to set. If None, sets all environments.
+    """
+    if self._delay_buffer is not None:
+      self._delay_buffer.set_lags(lags, env_ids)
+
+  def get_command(self, data: EntityData) -> ActuatorCmd:
+    """Extract command data for this actuator from entity data.
+
+    Args:
+      data: The entity data containing all state and target information.
+
+    Returns:
+      ActuatorCmd with appropriate data based on transmission type.
+    """
+    if self.transmission_type == TransmissionType.JOINT:
+      return ActuatorCmd(
+        position_target=data.joint_pos_target[:, self.target_ids],
+        velocity_target=data.joint_vel_target[:, self.target_ids],
+        effort_target=data.joint_effort_target[:, self.target_ids],
+        pos=data.joint_pos[:, self.target_ids],
+        vel=data.joint_vel[:, self.target_ids],
+      )
+    elif self.transmission_type == TransmissionType.TENDON:
+      return ActuatorCmd(
+        position_target=data.tendon_len_target[:, self.target_ids],
+        velocity_target=data.tendon_vel_target[:, self.target_ids],
+        effort_target=data.tendon_effort_target[:, self.target_ids],
+        pos=data.tendon_len[:, self.target_ids],
+        vel=data.tendon_vel[:, self.target_ids],
+      )
+    elif self.transmission_type == TransmissionType.SITE:
+      assert self._site_zeros is not None
+      return ActuatorCmd(
+        position_target=self._site_zeros,
+        velocity_target=self._site_zeros,
+        effort_target=data.site_effort_target[:, self.target_ids],
+        pos=self._site_zeros,
+        vel=self._site_zeros,
+      )
+    else:
+      raise ValueError(f"Unknown transmission type: {self.transmission_type}")
+
+  @abstractmethod
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    """Compute low-level actuator control signal from high-level commands.
+
+    Args:
+      cmd: High-level actuator command.
+
+    Returns:
+      Control signal tensor of shape (num_envs, num_actuators).
+    """
+    raise NotImplementedError
+
+  # Optional methods.
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    """Reset actuator state for specified environments.
+
+    Resets delay buffers if present. Subclasses that override this should
+    call ``super().reset(env_ids)``.
+
+    Args:
+      env_ids: Environment indices to reset. If None, reset all environments.
+    """
+    if self._delay_buffer is not None:
+      self._delay_buffer.reset(env_ids)
+
+  def update(self, dt: float) -> None:
+    """Update actuator state after a simulation step.
+
+    Base implementation does nothing. Override in subclasses that need
+    per-step updates.
+
+    Args:
+      dt: Time step in seconds.
+    """
+    del dt  # Unused.
diff --git a/src/mjlab/actuator/builtin_actuator.py b/src/mjlab/actuator/builtin_actuator.py
new file mode 100644
index 0000000..2f7cfa4
--- /dev/null
+++ b/src/mjlab/actuator/builtin_actuator.py
@@ -0,0 +1,623 @@
+"""MuJoCo built-in actuators.
+
+This module provides actuators that use MuJoCo's native actuator implementations,
+created programmatically via the MjSpec API.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import TYPE_CHECKING
+
+import mujoco
+import numpy as np
+import torch
+
+from mjlab.actuator.actuator import (
+  Actuator,
+  ActuatorCfg,
+  ActuatorCmd,
+  TransmissionType,
+)
+from mjlab.utils.spec import (
+  apply_target_overrides,
+  create_motor_actuator,
+  create_muscle_actuator,
+  create_position_actuator,
+  create_velocity_actuator,
+)
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+
+
+@dataclass(kw_only=True)
+class BuiltinPositionActuatorCfg(ActuatorCfg):
+  """Configuration for MuJoCo built-in position actuator.
+
+  Under the hood, this creates a <position> actuator for each target and sets the
+  stiffness, damping and effort limits accordingly. If armature or frictionloss are
+  set, they override the corresponding joint/tendon properties from XML.
+  """
+
+  stiffness: float
+  """PD proportional gain."""
+  damping: float
+  """PD derivative gain."""
+  effort_limit: float | None = None
+  """Maximum actuator force/torque. If None, no limit is applied."""
+
+  def __post_init__(self) -> None:
+    super().__post_init__()
+    if self.transmission_type == TransmissionType.SITE:
+      raise ValueError(
+        "BuiltinPositionActuatorCfg does not support SITE transmission. "
+        "Use BuiltinMotorActuatorCfg for site transmission."
+      )
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> BuiltinPositionActuator:
+    return BuiltinPositionActuator(self, entity, target_ids, target_names)
+
+
+class BuiltinPositionActuator(Actuator[BuiltinPositionActuatorCfg]):
+  """MuJoCo built-in position actuator."""
+
+  def __init__(
+    self,
+    cfg: BuiltinPositionActuatorCfg,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    super().__init__(cfg, entity, target_ids, target_names)
+
+  def edit_spec(self, spec: mujoco.MjSpec, target_names: list[str]) -> None:
+    # Add <position> actuator to spec, one per target.
+    for target_name in target_names:
+      actuator = create_position_actuator(
+        spec,
+        target_name,
+        stiffness=self.cfg.stiffness,
+        damping=self.cfg.damping,
+        effort_limit=self.cfg.effort_limit,
+        armature=self.cfg.armature,
+        frictionloss=self.cfg.frictionloss,
+        viscous_damping=self.cfg.viscous_damping,
+        transmission_type=self.cfg.transmission_type,
+      )
+      self._mjs_actuators.append(actuator)
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    return cmd.position_target
+
+
+@dataclass(kw_only=True)
+class BuiltinPdActuatorCfg(ActuatorCfg):
+  """Implicit-integration version of IdealPdActuator.
+
+  Both consume a position target and a velocity target with kp/kd gains. The
+  difference is in how the PD is delivered to MuJoCo: IdealPdActuator computes
+  the PD force in Python and feeds it to a ``<motor>`` element, which MuJoCo
+  sees as an opaque external force. This actuator expresses the PD as native
+  MuJoCo elements (a ``<position>`` carrying kp, a ``<velocity>`` carrying kd),
+  so the implicit and implicitfast integrators include the kp/kd derivatives
+  in their velocity update. That makes the actuator numerically stable at
+  gain/timestep combinations where explicit Python PD would diverge, which
+  matters when you want to run a real motor's stiff on-board PD gains in sim.
+  """
+
+  stiffness: float
+  """Proportional gain (kp)."""
+  damping: float
+  """Derivative gain (kd)."""
+  effort_limit: float | None = None
+  """Maximum total torque applied to the joint or tendon. Enforced as a
+  sum-clamp on the two PD terms via jnt_actfrcrange (JOINT) or
+  tendon_actfrcrange (TENDON). None leaves the limit unset."""
+
+  def __post_init__(self) -> None:
+    super().__post_init__()
+    if self.transmission_type == TransmissionType.SITE:
+      raise ValueError(
+        "BuiltinPdActuatorCfg does not support SITE transmission. "
+        "Use BuiltinMotorActuatorCfg for site transmission."
+      )
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> BuiltinPdActuator:
+    return BuiltinPdActuator(self, entity, target_ids, target_names)
+
+
+class BuiltinPdActuator(Actuator[BuiltinPdActuatorCfg]):
+  """MuJoCo native PD: paired <position> + <velocity> elements per target."""
+
+  def __init__(
+    self,
+    cfg: BuiltinPdActuatorCfg,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    super().__init__(cfg, entity, target_ids, target_names)
+
+  @property
+  def num_targets(self) -> int:
+    """Number of targets. ``ctrl_ids`` is laid out as ``[pos..., vel...]``,
+    each block of length ``num_targets``."""
+    return len(self._target_ids_list)
+
+  def edit_spec(self, spec: mujoco.MjSpec, target_names: list[str]) -> None:
+    # Position elements first, then velocity elements, so ctrl_ids is laid out
+    # as [pos_0..pos_{N-1}, vel_0..vel_{N-1}].
+    for target_name in target_names:
+      pos_act = create_position_actuator(
+        spec,
+        target_name,
+        actuator_name=f"{target_name}_pd_pos",
+        stiffness=self.cfg.stiffness,
+        damping=0.0,  # damping lives on the <velocity> element.
+        armature=self.cfg.armature,
+        frictionloss=self.cfg.frictionloss,
+        viscous_damping=self.cfg.viscous_damping,
+        transmission_type=self.cfg.transmission_type,
+      )
+      self._mjs_actuators.append(pos_act)
+    for target_name in target_names:
+      vel_act = create_velocity_actuator(
+        spec,
+        target_name,
+        actuator_name=f"{target_name}_pd_vel",
+        damping=self.cfg.damping,
+        transmission_type=self.cfg.transmission_type,
+      )
+      self._mjs_actuators.append(vel_act)
+    # Effort limit: sum-clamp on the joint/tendon, not on each element.
+    if self.cfg.effort_limit is not None:
+      lim = self.cfg.effort_limit
+      for target_name in target_names:
+        if self.cfg.transmission_type == TransmissionType.JOINT:
+          target = spec.joint(target_name)
+        else:
+          target = spec.tendon(target_name)
+        target.actfrclimited = mujoco.mjtLimited.mjLIMITED_TRUE
+        target.actfrcrange[:] = np.array([-lim, lim])
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    return torch.cat((cmd.position_target, cmd.velocity_target), dim=1)
+
+
+@dataclass(kw_only=True)
+class BuiltinMotorActuatorCfg(ActuatorCfg):
+  """Configuration for MuJoCo built-in motor actuator.
+
+  Under the hood, this creates a <motor> actuator for each target and sets its effort
+  limit and gear ratio accordingly. If armature or frictionloss are set, they override
+  the corresponding joint/tendon properties from XML.
+  """
+
+  effort_limit: float
+  """Maximum actuator effort."""
+  gear: float = 1.0
+  """Actuator gear ratio."""
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> BuiltinMotorActuator:
+    return BuiltinMotorActuator(self, entity, target_ids, target_names)
+
+
+class BuiltinMotorActuator(Actuator[BuiltinMotorActuatorCfg]):
+  """MuJoCo built-in motor actuator."""
+
+  def __init__(
+    self,
+    cfg: BuiltinMotorActuatorCfg,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    super().__init__(cfg, entity, target_ids, target_names)
+
+  def edit_spec(self, spec: mujoco.MjSpec, target_names: list[str]) -> None:
+    # Add <motor> actuator to spec, one per target.
+    for target_name in target_names:
+      actuator = create_motor_actuator(
+        spec,
+        target_name,
+        effort_limit=self.cfg.effort_limit,
+        gear=self.cfg.gear,
+        armature=self.cfg.armature,
+        frictionloss=self.cfg.frictionloss,
+        viscous_damping=self.cfg.viscous_damping,
+        transmission_type=self.cfg.transmission_type,
+      )
+      self._mjs_actuators.append(actuator)
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    return cmd.effort_target
+
+
+def _or_zeros(t: tuple[float, ...] | None, n: int) -> list[float]:
+  return list(t) if t is not None else [0.0] * n
+
+
+class DcMotorInputMode(IntEnum):
+  """What the ``ctrl`` signal of a ``<dcmotor>`` represents.
+
+  Values match MuJoCo's enum, consumed by mjs_setToDCMotor and read as gainprm[8].
+  """
+
+  VOLTAGE = 0
+  POSITION = 1
+  VELOCITY = 2
+
+
+@dataclass(frozen=True)
+class DcMotorDatasheetParams:
+  """Datasheet characterization of a DC motor."""
+
+  nominal_voltage: float
+  """Nominal (rated) voltage V_n [V]."""
+  stall_torque: float
+  """Stall torque tau_stall at V_n [N*m]."""
+  no_load_speed: float
+  """No-load angular velocity omega_no_load at V_n [rad/s]."""
+
+  def _pack(self) -> tuple[list[float], float, list[float]]:
+    """Returns (motorconst, resistance, nominal) for set_to_dcmotor."""
+    return (
+      [0.0, 0.0],
+      0.0,
+      [self.nominal_voltage, self.stall_torque, self.no_load_speed],
+    )
+
+
+@dataclass(frozen=True)
+class DcMotorPhysicalParams:
+  """Physical characterization of a DC motor."""
+
+  kt: float
+  """Torque constant [N*m/A]."""
+  ke: float
+  """Back-EMF constant [V*s/rad]."""
+  resistance: float
+  """Terminal resistance R [Ohm]."""
+
+  def _pack(self) -> tuple[list[float], float, list[float]]:
+    """Returns (motorconst, resistance, nominal) for set_to_dcmotor."""
+    return [self.kt, self.ke], self.resistance, [0.0, 0.0, 0.0]
+
+
+@dataclass(kw_only=True)
+class BuiltinDcMotorActuatorCfg(ActuatorCfg):
+  """Native MuJoCo ``<dcmotor>`` wrapper.
+
+  Models a DC motor: torque is derived from voltage via the motor constant K and
+  back-EMF, tau = K * (V - K * omega) / R. The back-EMF term lives in biasprm, so
+  MuJoCo's implicit / implicitfast integrators pick up its velocity derivative as
+  effective damping.
+
+  Three input modes select what ctrl carries:
+
+  * VOLTAGE: ctrl is the drive voltage. cmd.effort_target carries volts, not torque.
+  * POSITION / VELOCITY: an internal PID closes on the setpoint and the motor produces
+    torque from its (Vmax-clamped) voltage output.
+
+  Motor characterization: pass either DcMotorDatasheetParams or DcMotorPhysicalParams
+  as motor_params. mjs_setToDCMotor derives K and R (including the viscous-damping
+  correction) and packs the generic gainprm / biasprm / dynprm slots.
+
+  Optional extensions, off by default: integral_gain / integral_limit, slew_rate,
+  inductance / electrical_time_constant, thermal, lugre, cogging.
+
+  dr.pd_gains randomizes only kp and kd; for DR over the extensions, write directly to
+  actuator_gainprm or actuator_dynprm.
+  """
+
+  motor_params: DcMotorDatasheetParams | DcMotorPhysicalParams
+  """Motor characterization. Datasheet form: (V_n, tau_stall, omega_no_load).
+  Physical form: (Kt, Ke, R)."""
+
+  mode: DcMotorInputMode = DcMotorInputMode.POSITION
+  """ctrl input semantics. See class docstring."""
+
+  stiffness: float = 0.0
+  """PID proportional gain kp. Required in POSITION / VELOCITY mode; must be
+  0 in VOLTAGE mode."""
+
+  damping: float = 0.0
+  """PID derivative gain kd. Used in POSITION / VELOCITY mode; must be 0 in
+  VOLTAGE mode."""
+
+  voltage_limit: float = 0.0
+  """Max drive voltage Vmax. Required in POSITION / VELOCITY mode (clamps the
+  PID output). In VOLTAGE mode it is an optional clamp on ctrl; 0 disables."""
+
+  integral_gain: float = 0.0
+  """PID integral gain ki. In position mode the integrator tracks
+  ki * integral(target - q); in velocity mode, ki * (integral(target) - q).
+  Must be 0 in VOLTAGE mode."""
+
+  integral_limit: float = 0.0
+  """Anti-windup clamp Imax on the integrator state. 0 disables (the
+  integrator can run away)."""
+
+  slew_rate: float = 0.0
+  """Max rate of change of ctrl per second. 0 disables."""
+
+  effort_limit: float | None = None
+  """Continuous torque cap [N*m]. Sets actuator_forcerange. None leaves the
+  per-element forcerange unset."""
+
+  gear: float = 1.0
+  """Mechanical gear ratio."""
+
+  inductance: float = 0.0
+  """Winding inductance L [H]. Enables first-order electrical dynamics on the
+  motor current. MuJoCo internally uses te = L / R; pass
+  electrical_time_constant directly to skip the divide. 0 disables."""
+
+  electrical_time_constant: float = 0.0
+  """Alternative to inductance: specify te [s] directly. Ignored if
+  inductance > 0. 0 disables."""
+
+  thermal: tuple[float, float, float, float, float, float] | None = None
+  """Thermal model (R_thermal, C_thermal, tau_thermal, alpha, T0, T_ambient).
+  See MuJoCo's ``<dcmotor thermal=...>`` reference for units and which of the
+  first three may be underspecified. Effective resistance becomes
+  R * (1 + alpha * (T + T_ambient - T0)). None disables."""
+
+  cogging: tuple[float, float, float] | None = None
+  """Cogging torque (amplitude, periodicity, phase) in (N*m, cycles per unit
+  length, rad). Models magnetic torque ripple from rotor-stator interaction;
+  at joint angle q the contribution is amplitude * sin(periodicity * q + phase).
+
+  Added *after* effort_limit is enforced, matching MuJoCo's physical model:
+  effort_limit bounds the electromagnetic torque (the current limit), not the
+  mechanical torque. Total joint torque can exceed effort_limit by up to
+  amplitude. None disables."""
+
+  lugre: tuple[float, float, float, float, float] | None = None
+  """LuGre friction (sigma0, sigma1, F_Coulomb, F_Stribeck, v_Stribeck).
+  Stick-slip friction with bristle-deflection state. Subtracted from joint
+  torque after the effort_limit clamp (mechanical, like cogging). None
+  disables."""
+
+  def __post_init__(self) -> None:
+    super().__post_init__()
+    if self.transmission_type == TransmissionType.SITE:
+      raise ValueError(
+        "BuiltinDcMotorActuatorCfg does not support SITE transmission. "
+        "Use BuiltinMotorActuatorCfg for site transmission."
+      )
+
+    if self.mode in (DcMotorInputMode.POSITION, DcMotorInputMode.VELOCITY):
+      if self.stiffness <= 0.0:
+        raise ValueError(f"{self.mode.name} mode requires stiffness > 0.")
+      if self.voltage_limit <= 0.0:
+        raise ValueError(f"{self.mode.name} mode requires voltage_limit > 0.")
+    else:
+      if self.stiffness != 0.0 or self.damping != 0.0 or self.integral_gain != 0.0:
+        raise ValueError(
+          "stiffness, damping, and integral_gain are unused in VOLTAGE mode."
+        )
+
+    for name in (
+      "integral_gain",
+      "integral_limit",
+      "slew_rate",
+      "inductance",
+      "electrical_time_constant",
+    ):
+      if getattr(self, name) < 0.0:
+        raise ValueError(f"{name} must be non-negative.")
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> BuiltinDcMotorActuator:
+    return BuiltinDcMotorActuator(self, entity, target_ids, target_names)
+
+
+class BuiltinDcMotorActuator(Actuator[BuiltinDcMotorActuatorCfg]):
+  """MuJoCo native ``<dcmotor>``: one actuator per target."""
+
+  def edit_spec(self, spec: mujoco.MjSpec, target_names: list[str]) -> None:
+    cfg = self.cfg
+    motorconst, resistance, nominal = cfg.motor_params._pack()
+    saturation = (
+      [cfg.effort_limit, 0.0, 0.0] if cfg.effort_limit is not None else [0.0] * 3
+    )
+    controller = [
+      cfg.stiffness,  # kp
+      cfg.integral_gain,  # ki
+      cfg.damping,  # kd
+      cfg.slew_rate,  # slewmax
+      cfg.integral_limit,  # Imax (anti-windup)
+      cfg.voltage_limit,  # v_max
+    ]
+    # SITE is rejected in __post_init__, so only JOINT and TENDON remain.
+    trntype = (
+      mujoco.mjtTrn.mjTRN_JOINT
+      if cfg.transmission_type == TransmissionType.JOINT
+      else mujoco.mjtTrn.mjTRN_TENDON
+    )
+
+    for target_name in target_names:
+      actuator = spec.add_actuator(name=target_name, target=target_name)
+      actuator.trntype = trntype
+      actuator.gear[0] = cfg.gear
+      actuator.set_to_dcmotor(
+        motorconst=motorconst,
+        resistance=resistance,
+        nominal=nominal,
+        saturation=saturation,
+        controller=controller,
+        cogging=_or_zeros(cfg.cogging, 3),
+        inductance=[cfg.inductance, cfg.electrical_time_constant],
+        thermal=_or_zeros(cfg.thermal, 6),
+        lugre=_or_zeros(cfg.lugre, 5),
+        input_mode=cfg.mode,
+      )
+
+      apply_target_overrides(
+        spec,
+        target_name,
+        cfg.transmission_type,
+        armature=cfg.armature,
+        frictionloss=cfg.frictionloss,
+        viscous_damping=cfg.viscous_damping,
+      )
+
+      self._mjs_actuators.append(actuator)
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    if self.cfg.mode == DcMotorInputMode.POSITION:
+      return cmd.position_target
+    if self.cfg.mode == DcMotorInputMode.VELOCITY:
+      return cmd.velocity_target
+    # voltage mode: ctrl is the drive voltage carried in effort_target.
+    return cmd.effort_target
+
+
+@dataclass(kw_only=True)
+class BuiltinVelocityActuatorCfg(ActuatorCfg):
+  """Configuration for MuJoCo built-in velocity actuator.
+
+  Under the hood, this creates a <velocity> actuator for each target and sets the
+  damping gain. If armature or frictionloss are set, they override the corresponding
+  joint/tendon properties from XML.
+  """
+
+  damping: float
+  """Damping gain."""
+  effort_limit: float | None = None
+  """Maximum actuator force/torque. If None, no limit is applied."""
+
+  def __post_init__(self) -> None:
+    super().__post_init__()
+    if self.transmission_type == TransmissionType.SITE:
+      raise ValueError(
+        "BuiltinVelocityActuatorCfg does not support SITE transmission. "
+        "Use BuiltinMotorActuatorCfg for site transmission."
+      )
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> BuiltinVelocityActuator:
+    return BuiltinVelocityActuator(self, entity, target_ids, target_names)
+
+
+class BuiltinVelocityActuator(Actuator[BuiltinVelocityActuatorCfg]):
+  """MuJoCo built-in velocity actuator."""
+
+  def __init__(
+    self,
+    cfg: BuiltinVelocityActuatorCfg,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    super().__init__(cfg, entity, target_ids, target_names)
+
+  def edit_spec(self, spec: mujoco.MjSpec, target_names: list[str]) -> None:
+    # Add <velocity> actuator to spec, one per target.
+    for target_name in target_names:
+      actuator = create_velocity_actuator(
+        spec,
+        target_name,
+        damping=self.cfg.damping,
+        effort_limit=self.cfg.effort_limit,
+        armature=self.cfg.armature,
+        frictionloss=self.cfg.frictionloss,
+        viscous_damping=self.cfg.viscous_damping,
+        transmission_type=self.cfg.transmission_type,
+      )
+      self._mjs_actuators.append(actuator)
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    return cmd.velocity_target
+
+
+@dataclass(kw_only=True)
+class BuiltinMuscleActuatorCfg(ActuatorCfg):
+  """Configuration for MuJoCo built-in muscle actuator."""
+
+  length_range: tuple[float, float] = (0.0, 0.0)
+  """Length range for muscle actuator."""
+  gear: float = 1.0
+  """Gear ratio."""
+  timeconst: tuple[float, float] = (0.01, 0.04)
+  """Activation and deactivation time constants."""
+  tausmooth: float = 0.0
+  """Smoothing time constant."""
+  range: tuple[float, float] = (0.75, 1.05)
+  """Operating range of normalized muscle length."""
+  force: float = -1.0
+  """Peak force (if -1, defaults to scale * FLV)."""
+  scale: float = 200.0
+  """Force scaling factor."""
+  lmin: float = 0.5
+  """Minimum normalized muscle length."""
+  lmax: float = 1.6
+  """Maximum normalized muscle length."""
+  vmax: float = 1.5
+  """Maximum normalized muscle velocity."""
+  fpmax: float = 1.3
+  """Passive force at lmax."""
+  fvmax: float = 1.2
+  """Active force at -vmax."""
+
+  def __post_init__(self) -> None:
+    super().__post_init__()
+    if self.transmission_type == TransmissionType.SITE:
+      raise ValueError(
+        "BuiltinMuscleActuatorCfg does not support SITE transmission. "
+        "Use BuiltinMotorActuatorCfg for site transmission."
+      )
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> BuiltinMuscleActuator:
+    return BuiltinMuscleActuator(self, entity, target_ids, target_names)
+
+
+class BuiltinMuscleActuator(Actuator[BuiltinMuscleActuatorCfg]):
+  """MuJoCo built-in muscle actuator."""
+
+  def __init__(
+    self,
+    cfg: BuiltinMuscleActuatorCfg,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    super().__init__(cfg, entity, target_ids, target_names)
+
+  def edit_spec(self, spec: mujoco.MjSpec, target_names: list[str]) -> None:
+    # Add <muscle> actuator to spec, one per target.
+    for target_name in target_names:
+      actuator = create_muscle_actuator(
+        spec,
+        target_name,
+        length_range=self.cfg.length_range,
+        gear=self.cfg.gear,
+        timeconst=self.cfg.timeconst,
+        tausmooth=self.cfg.tausmooth,
+        range=self.cfg.range,
+        force=self.cfg.force,
+        scale=self.cfg.scale,
+        lmin=self.cfg.lmin,
+        lmax=self.cfg.lmax,
+        vmax=self.cfg.vmax,
+        fpmax=self.cfg.fpmax,
+        fvmax=self.cfg.fvmax,
+        transmission_type=self.cfg.transmission_type,
+      )
+      self._mjs_actuators.append(actuator)
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    return cmd.effort_target
diff --git a/src/mjlab/actuator/builtin_group.py b/src/mjlab/actuator/builtin_group.py
new file mode 100644
index 0000000..39b791f
--- /dev/null
+++ b/src/mjlab/actuator/builtin_group.py
@@ -0,0 +1,192 @@
+"""Batch ctrl writes for builtin actuators.
+
+Builtin actuators have identity compute(): they just pass the target through to ctrl.
+Instead of looping over each actuator individually, this module reads the target tensor
+and writes ctrl in one batched operation per actuator type. Delayed builtins go through
+a shared DelayBuffer first.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.actuator.actuator import TransmissionType
+from mjlab.actuator.builtin_actuator import (
+  BuiltinMotorActuator,
+  BuiltinMuscleActuator,
+  BuiltinPositionActuator,
+  BuiltinVelocityActuator,
+)
+from mjlab.utils.buffers import DelayBuffer
+
+if TYPE_CHECKING:
+  from mjlab.actuator.actuator import Actuator
+  from mjlab.entity.data import EntityData
+
+BuiltinActuatorType = (
+  BuiltinMotorActuator
+  | BuiltinMuscleActuator
+  | BuiltinPositionActuator
+  | BuiltinVelocityActuator
+)
+
+# Maps (actuator_type, transmission_type) to EntityData target tensor attribute name.
+_TARGET_TENSOR_MAP: dict[tuple[type[BuiltinActuatorType], TransmissionType], str] = {
+  (BuiltinPositionActuator, TransmissionType.JOINT): "joint_pos_target",
+  (BuiltinVelocityActuator, TransmissionType.JOINT): "joint_vel_target",
+  (BuiltinMotorActuator, TransmissionType.JOINT): "joint_effort_target",
+  (BuiltinPositionActuator, TransmissionType.TENDON): "tendon_len_target",
+  (BuiltinVelocityActuator, TransmissionType.TENDON): "tendon_vel_target",
+  (BuiltinMotorActuator, TransmissionType.TENDON): "tendon_effort_target",
+  (BuiltinMotorActuator, TransmissionType.SITE): "site_effort_target",
+  (BuiltinMuscleActuator, TransmissionType.JOINT): "joint_effort_target",
+  (BuiltinMuscleActuator, TransmissionType.TENDON): "tendon_effort_target",
+}
+
+
+@dataclass
+class _FusedDelayGroup:
+  """A fused group of delayed builtin actuators sharing delay config."""
+
+  target_attr: str
+  target_ids: torch.Tensor
+  ctrl_ids: torch.Tensor
+  min_lag: int
+  max_lag: int
+  hold_prob: float
+  update_period: int
+  per_env_phase: bool
+  absorbed_actuators: list[Actuator] = field(default_factory=list)
+  delay_buffer: DelayBuffer | None = field(default=None, init=False)
+
+
+@dataclass
+class BuiltinActuatorGroup:
+  """Groups builtin actuators for batch processing."""
+
+  _index_groups: dict[
+    tuple[type[BuiltinActuatorType], TransmissionType],
+    tuple[torch.Tensor, torch.Tensor],
+  ]
+  _delayed_groups: list[_FusedDelayGroup]
+
+  @staticmethod
+  def process(
+    actuators: list[Actuator],
+  ) -> tuple[BuiltinActuatorGroup, tuple[Actuator, ...]]:
+    """Classify actuators into builtin groups and custom actuators.
+
+    Non-delayed builtins go into direct index groups. Delayed builtins with matching
+    delay config are fused into shared delay buffer groups. Everything else is returned
+    as custom actuators.
+
+    Args:
+      actuators: List of initialized actuators to process.
+
+    Returns:
+      A tuple of (builtin group, custom actuators).
+    """
+    builtin_groups: dict[
+      tuple[type[BuiltinActuatorType], TransmissionType], list[Actuator]
+    ] = {}
+    delayed_grouped: dict[tuple, list[Actuator]] = {}
+    custom_actuators: list[Actuator] = []
+
+    for act in actuators:
+      if not isinstance(act, BuiltinActuatorType):
+        custom_actuators.append(act)
+        continue
+
+      if not act.has_delay:
+        key: tuple[type[BuiltinActuatorType], TransmissionType] = (
+          type(act),
+          act.cfg.transmission_type,
+        )
+        builtin_groups.setdefault(key, []).append(act)
+        continue
+
+      # Delayed builtin: fuse into shared delay buffer group.
+      delay_key = (
+        type(act),
+        act.cfg.transmission_type,
+        act.cfg.delay_min_lag,
+        act.cfg.delay_max_lag,
+        act.cfg.delay_hold_prob,
+        act.cfg.delay_update_period,
+        act.cfg.delay_per_env_phase,
+      )
+      delayed_grouped.setdefault(delay_key, []).append(act)
+
+    # Build non-delayed index groups.
+    index_groups: dict[
+      tuple[type[BuiltinActuatorType], TransmissionType],
+      tuple[torch.Tensor, torch.Tensor],
+    ] = {
+      key: (
+        torch.cat([a.target_ids for a in acts], dim=0),
+        torch.cat([a.ctrl_ids for a in acts], dim=0),
+      )
+      for key, acts in builtin_groups.items()
+    }
+
+    # Build delayed fused groups.
+    delayed_groups: list[_FusedDelayGroup] = []
+    for (base_type, transmission_type, *_), acts in delayed_grouped.items():
+      target_attr = _TARGET_TENSOR_MAP[(base_type, transmission_type)]
+      target_ids = torch.cat([a.target_ids for a in acts], dim=0)
+      ctrl_ids = torch.cat([a.ctrl_ids for a in acts], dim=0)
+      cfg = acts[0].cfg
+      delayed_groups.append(
+        _FusedDelayGroup(
+          target_attr=target_attr,
+          target_ids=target_ids,
+          ctrl_ids=ctrl_ids,
+          min_lag=cfg.delay_min_lag,
+          max_lag=cfg.delay_max_lag,
+          hold_prob=cfg.delay_hold_prob,
+          update_period=cfg.delay_update_period,
+          per_env_phase=cfg.delay_per_env_phase,
+          absorbed_actuators=list(acts),
+        )
+      )
+
+    return BuiltinActuatorGroup(index_groups, delayed_groups), tuple(custom_actuators)
+
+  def initialize(self, num_envs: int, device: str) -> None:
+    """Create fused delay buffers for delayed builtin groups."""
+    for group in self._delayed_groups:
+      group.delay_buffer = DelayBuffer(
+        min_lag=group.min_lag,
+        max_lag=group.max_lag,
+        batch_size=num_envs,
+        device=device,
+        hold_prob=group.hold_prob,
+        update_period=group.update_period,
+        per_env_phase=group.per_env_phase,
+      )
+      # Alias the fused buffer into each absorbed actuator so that per-actuator reset
+      # and set_lags operate on the shared buffer.
+      for act in group.absorbed_actuators:
+        act._delay_buffer = group.delay_buffer
+
+  def apply_controls(self, data: EntityData) -> None:
+    """Write builtin actuator controls to simulation data."""
+    # Non-delayed: direct write.
+    for (actuator_type, transmission_type), (
+      target_ids,
+      ctrl_ids,
+    ) in self._index_groups.items():
+      attr_name = _TARGET_TENSOR_MAP[(actuator_type, transmission_type)]
+      target_tensor = getattr(data, attr_name)
+      data.write_ctrl(target_tensor[:, target_ids], ctrl_ids)
+
+    # Delayed: append to buffer, compute delayed value, write.
+    for group in self._delayed_groups:
+      assert group.delay_buffer is not None
+      target_tensor = getattr(data, group.target_attr)
+      targets = target_tensor[:, group.target_ids]
+      group.delay_buffer.append(targets)
+      data.write_ctrl(group.delay_buffer.compute(), group.ctrl_ids)
diff --git a/src/mjlab/actuator/dc_actuator.py b/src/mjlab/actuator/dc_actuator.py
new file mode 100644
index 0000000..b1396c9
--- /dev/null
+++ b/src/mjlab/actuator/dc_actuator.py
@@ -0,0 +1,189 @@
+"""DC motor actuator with velocity-based saturation model.
+
+This module provides a DC motor actuator that implements a realistic torque-speed
+curve for more accurate motor behavior simulation.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+import mujoco
+import mujoco_warp as mjwarp
+import torch
+
+from mjlab.actuator.actuator import ActuatorCmd
+from mjlab.actuator.pd_actuator import IdealPdActuator, IdealPdActuatorCfg, pd_torque
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+
+DcMotorCfgT = TypeVar("DcMotorCfgT", bound="DcMotorActuatorCfg")
+
+
+def dc_motor_clip(
+  effort: torch.Tensor,
+  saturation_effort: torch.Tensor,
+  velocity_limit: torch.Tensor,
+  force_limit: torch.Tensor,
+  vel: torch.Tensor,
+) -> torch.Tensor:
+  """Clip effort to the DC motor torque-speed curve.
+
+  Linear torque-speed curve: full saturation_effort at zero velocity falling to
+  zero at velocity_limit, further bounded by the continuous force_limit. Shared
+  by DcMotorActuator._clip_effort and the fused control law so the curve lives in
+  one place.
+
+  The corner velocity where the curve intersects force_limit is recomputed from
+  force_limit every call rather than cached, since force_limit can be
+  domain-randomized after initialize() (e.g. via set_effort_limit); caching it
+  would silently go stale.
+  """
+  vel_at_effort_lim = velocity_limit * (1 + force_limit / saturation_effort)
+  vel_clipped = torch.clamp(vel, min=-vel_at_effort_lim, max=vel_at_effort_lim)
+  torque_speed_top = saturation_effort * (1.0 - vel_clipped / velocity_limit)
+  torque_speed_bottom = saturation_effort * (-1.0 - vel_clipped / velocity_limit)
+  max_effort = torch.clamp(torque_speed_top, max=force_limit)
+  min_effort = torch.clamp(torque_speed_bottom, min=-force_limit)
+  return torch.clamp(effort, min=min_effort, max=max_effort)
+
+
+@dataclass(kw_only=True)
+class DcMotorActuatorCfg(IdealPdActuatorCfg):
+  """Configuration for DC motor actuator with velocity-based saturation.
+
+  This actuator implements a DC motor torque-speed curve for more realistic
+  actuator behavior. The motor produces maximum torque (saturation_effort) at
+  zero velocity and reduces linearly to zero torque at maximum velocity.
+
+  Note: effort_limit should be explicitly set to a realistic value for proper
+  motor modeling. Using the default (inf) will trigger a warning. Use
+  IdealPdActuator if unlimited torque is desired.
+
+  For a native MuJoCo ``<dcmotor>`` with back-EMF, voltage saturation, and
+  configurable ``Kt`` / ``Ke`` / ``R``, see ``BuiltinDcMotorActuator``.
+  """
+
+  saturation_effort: float
+  """Peak motor torque at zero velocity (stall torque)."""
+
+  velocity_limit: float
+  """Maximum motor velocity (no-load speed)."""
+
+  def __post_init__(self) -> None:
+    """Validate DC motor parameters."""
+    super().__post_init__()
+    import warnings
+
+    if self.effort_limit == float("inf"):
+      warnings.warn(
+        "effort_limit is set to inf for DcMotorActuator, which creates an "
+        "unrealistic motor with unlimited continuous torque. Consider setting "
+        "effort_limit to your motor's continuous rating (<= saturation_effort). "
+        "Use IdealPdActuator if you truly want unlimited torque.",
+        UserWarning,
+        stacklevel=2,
+      )
+
+    if self.effort_limit > self.saturation_effort:
+      warnings.warn(
+        f"effort_limit ({self.effort_limit}) exceeds saturation_effort "
+        f"({self.saturation_effort}). For realistic motors, continuous torque "
+        "should be <= peak torque.",
+        UserWarning,
+        stacklevel=2,
+      )
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> DcMotorActuator:
+    return DcMotorActuator(self, entity, target_ids, target_names)
+
+
+class DcMotorActuator(IdealPdActuator[DcMotorCfgT], Generic[DcMotorCfgT]):
+  """DC motor actuator with velocity-based saturation model.
+
+  This actuator extends IdealPdActuator with a realistic DC motor model
+  that limits torque based on current joint velocity. The model implements
+  a linear torque-speed curve where:
+  - At zero velocity: can produce full saturation_effort (stall torque)
+  - At max velocity: can produce zero torque
+  - Between: torque limit varies linearly
+
+  The continuous torque limit (effort_limit) further constrains the output.
+  """
+
+  # Same stateless-law compute as IdealPd, with the torque-speed curve added to
+  # the law. The velocity feedback the curve needs comes straight from cmd.vel.
+  param_names = (
+    *IdealPdActuator.param_names,
+    "saturation_effort",
+    "velocity_limit_motor",
+  )
+
+  @staticmethod
+  def control_law(params: dict[str, torch.Tensor], cmd: ActuatorCmd) -> torch.Tensor:
+    torque = pd_torque(params["stiffness"], params["damping"], cmd)
+    return dc_motor_clip(
+      torque,
+      params["saturation_effort"],
+      params["velocity_limit_motor"],
+      params["force_limit"],
+      cmd.vel,
+    )
+
+  def __init__(
+    self,
+    cfg: DcMotorCfgT,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    super().__init__(cfg, entity, target_ids, target_names)
+    self.saturation_effort: torch.Tensor | None = None
+    self.velocity_limit_motor: torch.Tensor | None = None
+    self._joint_vel_clipped: torch.Tensor | None = None
+
+  def initialize(
+    self,
+    mj_model: mujoco.MjModel,
+    model: mjwarp.Model,
+    data: mjwarp.Data,
+    device: str,
+  ) -> None:
+    super().initialize(mj_model, model, data, device)
+
+    num_envs = data.nworld
+    num_joints = len(self._target_names)
+
+    self.saturation_effort = torch.full(
+      (num_envs, num_joints),
+      self.cfg.saturation_effort,
+      dtype=torch.float,
+      device=device,
+    )
+    self.velocity_limit_motor = torch.full(
+      (num_envs, num_joints),
+      self.cfg.velocity_limit,
+      dtype=torch.float,
+      device=device,
+    )
+    self._joint_vel_clipped = torch.zeros(num_envs, num_joints, device=device)
+
+  def _clip_effort(self, effort: torch.Tensor) -> torch.Tensor:
+    # Retained for LearnedMlpActuator, which has its own (stateful) compute and
+    # reuses this torque-speed clip. DcMotorActuator itself clips inside
+    # control_law via dc_motor_clip.
+    assert self.saturation_effort is not None
+    assert self.velocity_limit_motor is not None
+    assert self.force_limit is not None
+    assert self._joint_vel_clipped is not None
+    return dc_motor_clip(
+      effort,
+      self.saturation_effort,
+      self.velocity_limit_motor,
+      self.force_limit,
+      self._joint_vel_clipped,
+    )
diff --git a/src/mjlab/actuator/fused_group.py b/src/mjlab/actuator/fused_group.py
new file mode 100644
index 0000000..6ecc446
--- /dev/null
+++ b/src/mjlab/actuator/fused_group.py
@@ -0,0 +1,223 @@
+"""Batch compute for stateless-control-law actuators.
+
+Actuators like IdealPdActuator and DcMotorActuator evaluate their control law in
+PyTorch every physics substep. Done per actuator, a robot split into several
+groups (e.g. one per motor type) issues that many gathers, delay-buffer updates,
+control-law evaluations, and ctrl writes each substep. At small env counts (play
+mode with a synchronizing viewer) this is host-launch-bound and noticeably slow,
+whereas built-in actuators are already fused into one batched write.
+
+This module brings the same fusion to actuators whose control output is a
+stateless function of per-target parameters and the command. Such actuators apply
+their control law through the shared compute inherited from IdealPdActuator;
+keeping that compute is exactly what marks an actuator as fusable. Actuators with
+a custom compute (built-ins, XML, learned networks) are skipped, with no opt-out
+flag required.
+
+Fusable actuators sharing an exact type, transmission type, and delay config are
+fused into one group: their per-target parameters and indices are concatenated so
+the gather, optional delay, control law, and ctrl write each happen once for the
+whole group, behind a single shared DelayBuffer. SITE transmission is not fused.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.actuator.actuator import ActuatorCmd, TransmissionType, delay_command
+from mjlab.actuator.pd_actuator import IdealPdActuator
+from mjlab.utils.buffers import DelayBuffer
+
+if TYPE_CHECKING:
+  from mjlab.actuator.actuator import Actuator
+  from mjlab.entity.data import EntityData
+
+# Per transmission type, the EntityData attribute names for the five fields the
+# control law reads: (position_target, velocity_target, effort_target, position,
+# velocity).
+_FIELD_MAP: dict[TransmissionType, tuple[str, str, str, str, str]] = {
+  TransmissionType.JOINT: (
+    "joint_pos_target",
+    "joint_vel_target",
+    "joint_effort_target",
+    "joint_pos",
+    "joint_vel",
+  ),
+  TransmissionType.TENDON: (
+    "tendon_len_target",
+    "tendon_vel_target",
+    "tendon_effort_target",
+    "tendon_len",
+    "tendon_vel",
+  ),
+}
+
+
+def _is_fusable(act: Actuator) -> bool:
+  """An actuator is fusable iff it keeps the shared stateless-law compute.
+
+  IdealPd and DcMotor apply their control law through that inherited compute;
+  anything with a custom compute (built-ins, XML, and learned actuators,
+  including DcMotor subclasses that override it) is not fusable. Comparing the
+  bound function is immune to the inheritance trap an isinstance check would hit.
+  """
+  return (
+    type(act).compute is IdealPdActuator.compute
+    and act.cfg.transmission_type in _FIELD_MAP
+  )
+
+
+def _require(t: torch.Tensor | None) -> torch.Tensor:
+  assert t is not None
+  return t
+
+
+@dataclass
+class _FusedGroup:
+  """A fused group of actuators sharing type, transmission, and delay config."""
+
+  actuator_type: type[Actuator]
+  transmission_type: TransmissionType
+  target_ids: torch.Tensor
+  ctrl_ids: torch.Tensor
+  min_lag: int
+  max_lag: int
+  hold_prob: float
+  update_period: int
+  per_env_phase: bool
+  absorbed_actuators: list[Actuator] = field(default_factory=list)
+  params: dict[str, torch.Tensor] = field(default_factory=dict, init=False)
+  delay_buffer: DelayBuffer | None = field(default=None, init=False)
+
+  @property
+  def has_delay(self) -> bool:
+    return self.max_lag > 0
+
+
+@dataclass
+class FusedActuatorGroup:
+  """Groups stateless-control-law actuators for batch processing."""
+
+  _groups: list[_FusedGroup]
+
+  @staticmethod
+  def process(
+    actuators: tuple[Actuator, ...] | list[Actuator],
+  ) -> tuple[FusedActuatorGroup, tuple[Actuator, ...]]:
+    """Classify actuators into fused groups and remaining custom actuators.
+
+    Fusable actuators (see _is_fusable) with JOINT or TENDON transmission are
+    fused by (exact type, transmission type, delay config). Everything else is
+    returned unchanged for the per-actuator path.
+
+    Args:
+      actuators: List of initialized actuators to process.
+
+    Returns:
+      A tuple of (fused group, remaining custom actuators).
+    """
+    grouped: dict[tuple, list[Actuator]] = {}
+    remaining: list[Actuator] = []
+
+    for act in actuators:
+      if not _is_fusable(act):
+        remaining.append(act)
+        continue
+      key = (
+        type(act),
+        act.cfg.transmission_type,
+        act.cfg.delay_min_lag,
+        act.cfg.delay_max_lag,
+        act.cfg.delay_hold_prob,
+        act.cfg.delay_update_period,
+        act.cfg.delay_per_env_phase,
+      )
+      grouped.setdefault(key, []).append(act)
+
+    groups: list[_FusedGroup] = []
+    for (actuator_type, transmission_type, *_), acts in grouped.items():
+      cfg = acts[0].cfg
+      groups.append(
+        _FusedGroup(
+          actuator_type=actuator_type,
+          transmission_type=transmission_type,
+          target_ids=torch.cat([a.target_ids for a in acts], dim=0),
+          ctrl_ids=torch.cat([a.ctrl_ids for a in acts], dim=0),
+          min_lag=cfg.delay_min_lag,
+          max_lag=cfg.delay_max_lag,
+          hold_prob=cfg.delay_hold_prob,
+          update_period=cfg.delay_update_period,
+          per_env_phase=cfg.delay_per_env_phase,
+          absorbed_actuators=list(acts),
+        )
+      )
+
+    return FusedActuatorGroup(groups), tuple(remaining)
+
+  def initialize(self, num_envs: int, device: str) -> None:
+    """Concatenate parameters and create shared delay buffers for fused groups."""
+    for group in self._groups:
+      # Concatenate each control-law parameter across absorbed actuators, then
+      # alias every actuator's parameter back to a slice view of the fused tensor.
+      #
+      # Invariant: after this an absorbed actuator's parameter tensors are views
+      # into the group tensors. Mutations must be in-place (e.g. set_gains and
+      # set_effort_limit assign into a slice) so they write through to what the
+      # group computes with. Rebinding the attribute would silently detach it; the
+      # only rebind site is the actuator's initialize(), which runs before fusion.
+      for name in group.actuator_type.param_names:
+        group.params[name] = torch.cat(
+          [_require(getattr(a, name)) for a in group.absorbed_actuators], dim=1
+        )
+      offset = 0
+      for act in group.absorbed_actuators:
+        n = act.target_ids.numel()
+        for name in group.actuator_type.param_names:
+          setattr(act, name, group.params[name][:, offset : offset + n])
+        offset += n
+
+      if group.has_delay:
+        group.delay_buffer = DelayBuffer(
+          min_lag=group.min_lag,
+          max_lag=group.max_lag,
+          batch_size=num_envs,
+          device=device,
+          hold_prob=group.hold_prob,
+          update_period=group.update_period,
+          per_env_phase=group.per_env_phase,
+        )
+        # Alias the shared buffer into each absorbed actuator so per-actuator
+        # reset and set_lags operate on it.
+        for act in group.absorbed_actuators:
+          act._delay_buffer = group.delay_buffer
+
+  def apply_controls(self, data: EntityData) -> None:
+    """Compute and write fused actuator controls to simulation data."""
+    for group in self._groups:
+      pos_attr, vel_attr, eff_attr, cur_pos_attr, cur_vel_attr = _FIELD_MAP[
+        group.transmission_type
+      ]
+      ids = group.target_ids
+      pos_target = getattr(data, pos_attr)[:, ids]
+      vel_target = getattr(data, vel_attr)[:, ids]
+      effort_target = getattr(data, eff_attr)[:, ids]
+      pos = getattr(data, cur_pos_attr)[:, ids]
+      vel = getattr(data, cur_vel_attr)[:, ids]
+
+      if group.delay_buffer is not None:
+        pos_target, vel_target, effort_target = delay_command(
+          group.delay_buffer, pos_target, vel_target, effort_target
+        )
+
+      cmd = ActuatorCmd(
+        position_target=pos_target,
+        velocity_target=vel_target,
+        effort_target=effort_target,
+        pos=pos,
+        vel=vel,
+      )
+      torques = group.actuator_type.control_law(group.params, cmd)
+      data.write_ctrl(torques, group.ctrl_ids)
diff --git a/src/mjlab/actuator/learned_actuator.py b/src/mjlab/actuator/learned_actuator.py
new file mode 100644
index 0000000..f954933
--- /dev/null
+++ b/src/mjlab/actuator/learned_actuator.py
@@ -0,0 +1,208 @@
+"""Learned actuator models."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal
+
+import mujoco
+import mujoco_warp as mjwarp
+import torch
+
+from mjlab.actuator.actuator import ActuatorCmd
+from mjlab.actuator.dc_actuator import DcMotorActuator, DcMotorActuatorCfg
+from mjlab.utils.buffers import CircularBuffer
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+
+
+@dataclass(kw_only=True)
+class LearnedMlpActuatorCfg(DcMotorActuatorCfg):
+  """Configuration for MLP-based learned actuator model.
+
+  This actuator learns the mapping from joint commands and state history to
+  actual torque output. It's useful for capturing actuator dynamics that are
+  difficult to model analytically, such as delays, non-linearities, and
+  friction effects.
+
+  The network is trained offline using data from the real system and loaded
+  as a TorchScript file. The model uses a sliding window of historical joint
+  position errors and velocities as inputs.
+  """
+
+  network_file: str
+  """Path to the TorchScript file containing the trained MLP model."""
+
+  pos_scale: float
+  """Scaling factor for joint position error inputs to the network."""
+
+  vel_scale: float
+  """Scaling factor for joint velocity inputs to the network."""
+
+  torque_scale: float
+  """Scaling factor for torque outputs from the network."""
+
+  input_order: Literal["pos_vel", "vel_pos"] = "pos_vel"
+  """Order of inputs to the network.
+
+  - "pos_vel": position errors followed by velocities
+  - "vel_pos": velocities followed by position errors
+  """
+
+  history_length: int = 3
+  """Number of timesteps of history to use as network inputs.
+
+  For example, history_length=3 uses the current timestep plus the previous
+  2 timesteps (total of 3 frames).
+  """
+
+  # Learned actuators don't use stiffness/damping from PD controller.
+  stiffness: float = 0.0
+  damping: float = 0.0
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> LearnedMlpActuator:
+    return LearnedMlpActuator(self, entity, target_ids, target_names)
+
+
+class LearnedMlpActuator(DcMotorActuator[LearnedMlpActuatorCfg]):
+  """MLP-based learned actuator with joint history.
+
+  This actuator uses a trained neural network to map from joint commands and
+  state history to torque outputs. The network captures complex actuator
+  dynamics that are difficult to model analytically.
+
+  The actuator maintains circular buffers of joint position errors and
+  velocities, which are used as inputs to the MLP. The network outputs are
+  then scaled and clipped using the DC motor limits from the parent class.
+  """
+
+  def __init__(
+    self,
+    cfg: LearnedMlpActuatorCfg,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    super().__init__(cfg, entity, target_ids, target_names)
+    self.network: torch.jit.ScriptModule | None = None
+    self._pos_error_history: CircularBuffer | None = None
+    self._vel_history: CircularBuffer | None = None
+
+  def initialize(
+    self,
+    mj_model: mujoco.MjModel,
+    model: mjwarp.Model,
+    data: mjwarp.Data,
+    device: str,
+  ) -> None:
+    super().initialize(mj_model, model, data, device)
+
+    # Load the trained network from TorchScript file.
+    self.network = torch.jit.load(self.cfg.network_file, map_location=device)
+    assert self.network is not None
+    self.network.eval()
+
+    # Create history buffers.
+    num_envs = data.nworld
+
+    self._pos_error_history = CircularBuffer(
+      max_len=self.cfg.history_length,
+      batch_size=num_envs,
+      device=device,
+    )
+    self._vel_history = CircularBuffer(
+      max_len=self.cfg.history_length,
+      batch_size=num_envs,
+      device=device,
+    )
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    """Reset history buffers for specified environments.
+
+    Args:
+      env_ids: Environment indices to reset. If None, reset all environments.
+    """
+    super().reset(env_ids)
+    assert self._pos_error_history is not None
+    assert self._vel_history is not None
+
+    if env_ids is None:
+      self._pos_error_history.reset()
+      self._vel_history.reset()
+    elif isinstance(env_ids, slice):
+      # Convert slice to indices for CircularBuffer.
+      batch_size = self._pos_error_history.batch_size
+      indices = list(range(*env_ids.indices(batch_size)))
+      self._pos_error_history.reset(indices)
+      self._vel_history.reset(indices)
+    else:
+      self._pos_error_history.reset(env_ids)
+      self._vel_history.reset(env_ids)
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    """Compute actuator torques using the learned MLP model.
+
+    Args:
+      cmd: High-level actuator command containing targets and current state.
+
+    Returns:
+      Computed torque tensor of shape (num_envs, num_joints).
+    """
+    assert self.network is not None
+    assert self._pos_error_history is not None
+    assert self._vel_history is not None
+    assert self._joint_vel_clipped is not None
+
+    # Update history buffers with current state.
+    pos_error = cmd.position_target - cmd.pos
+    self._pos_error_history.append(pos_error)
+    self._vel_history.append(cmd.vel)
+
+    # Save velocity for DC motor clipping in parent class.
+    self._joint_vel_clipped[:] = cmd.vel
+
+    num_envs = cmd.pos.shape[0]
+    num_joints = cmd.pos.shape[1]
+
+    # Extract history from current to history_length-1 steps back.
+    # Each returns shape: (num_envs, num_joints).
+    pos_inputs = [
+      self._pos_error_history[lag] for lag in range(self.cfg.history_length)
+    ]
+    vel_inputs = [self._vel_history[lag] for lag in range(self.cfg.history_length)]
+
+    # Stack along feature dimension: (num_envs, num_joints, history_length).
+    pos_stacked = torch.stack(pos_inputs, dim=2)
+    vel_stacked = torch.stack(vel_inputs, dim=2)
+
+    # Reshape to (num_envs * num_joints, num_history_steps) for network.
+    pos_flat = pos_stacked.reshape(num_envs * num_joints, -1)
+    vel_flat = vel_stacked.reshape(num_envs * num_joints, -1)
+
+    # Scale and concatenate inputs based on specified order.
+    if self.cfg.input_order == "pos_vel":
+      network_input = torch.cat(
+        [pos_flat * self.cfg.pos_scale, vel_flat * self.cfg.vel_scale], dim=1
+      )
+    elif self.cfg.input_order == "vel_pos":
+      network_input = torch.cat(
+        [vel_flat * self.cfg.vel_scale, pos_flat * self.cfg.pos_scale], dim=1
+      )
+    else:
+      raise ValueError(
+        f"Invalid input order: {self.cfg.input_order}. Must be 'pos_vel' or 'vel_pos'."
+      )
+
+    # Run network inference.
+    with torch.inference_mode():
+      torques_flat = self.network(network_input)
+
+    # Reshape and scale output torques.
+    computed_torques = torques_flat.reshape(num_envs, num_joints)
+    computed_torques = computed_torques * self.cfg.torque_scale
+
+    # Clip using DC motor limits from parent class.
+    return self._clip_effort(computed_torques)
diff --git a/src/mjlab/actuator/pd_actuator.py b/src/mjlab/actuator/pd_actuator.py
new file mode 100644
index 0000000..c783c55
--- /dev/null
+++ b/src/mjlab/actuator/pd_actuator.py
@@ -0,0 +1,163 @@
+"""An ideal PD control actuator."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+import mujoco
+import mujoco_warp as mjwarp
+import torch
+
+from mjlab.actuator.actuator import Actuator, ActuatorCfg, ActuatorCmd
+from mjlab.utils.spec import create_motor_actuator
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+
+IdealPdCfgT = TypeVar("IdealPdCfgT", bound="IdealPdActuatorCfg")
+
+
+def pd_torque(
+  stiffness: torch.Tensor, damping: torch.Tensor, cmd: ActuatorCmd
+) -> torch.Tensor:
+  """Ideal PD control torque, unclamped.
+
+  kp * (pos_target - pos) + kd * (vel_target - vel) + effort_target. Shared by
+  the ideal PD and DC motor control laws so the PD sum lives in one place.
+  """
+  torque = stiffness * (cmd.position_target - cmd.pos)
+  torque += damping * (cmd.velocity_target - cmd.vel)
+  torque += cmd.effort_target
+  return torque
+
+
+@dataclass(kw_only=True)
+class IdealPdActuatorCfg(ActuatorCfg):
+  """Configuration for ideal PD actuator."""
+
+  stiffness: float
+  """PD stiffness (proportional gain)."""
+  damping: float
+  """PD damping (derivative gain)."""
+  effort_limit: float = float("inf")
+  """Maximum force/torque limit."""
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> IdealPdActuator:
+    return IdealPdActuator(self, entity, target_ids, target_names)
+
+
+class IdealPdActuator(Actuator, Generic[IdealPdCfgT]):
+  """Ideal PD control actuator."""
+
+  param_names = ("stiffness", "damping", "force_limit")
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    # Shared stateless-law compute. Keeping this (rather than writing a custom
+    # compute) is what marks an actuator as fusable; subclasses with a different
+    # control law (e.g. learned networks) override compute instead.
+    params = {name: getattr(self, name) for name in self.param_names}
+    return type(self).control_law(params, cmd)
+
+  @staticmethod
+  def control_law(params: dict[str, torch.Tensor], cmd: ActuatorCmd) -> torch.Tensor:
+    torque = pd_torque(params["stiffness"], params["damping"], cmd)
+    force_limit = params["force_limit"]
+    return torch.clamp(torque, -force_limit, force_limit)
+
+  def __init__(
+    self,
+    cfg: IdealPdCfgT,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    super().__init__(cfg, entity, target_ids, target_names)
+    self.stiffness: torch.Tensor | None = None
+    self.damping: torch.Tensor | None = None
+    self.force_limit: torch.Tensor | None = None
+    self.default_stiffness: torch.Tensor | None = None
+    self.default_damping: torch.Tensor | None = None
+    self.default_force_limit: torch.Tensor | None = None
+
+  def edit_spec(self, spec: mujoco.MjSpec, target_names: list[str]) -> None:
+    # Add <motor> actuator to spec, one per target.
+    for target_name in target_names:
+      actuator = create_motor_actuator(
+        spec,
+        target_name,
+        effort_limit=self.cfg.effort_limit,
+        armature=self.cfg.armature,
+        frictionloss=self.cfg.frictionloss,
+        viscous_damping=self.cfg.viscous_damping,
+        transmission_type=self.cfg.transmission_type,
+      )
+      self._mjs_actuators.append(actuator)
+
+  def initialize(
+    self,
+    mj_model: mujoco.MjModel,
+    model: mjwarp.Model,
+    data: mjwarp.Data,
+    device: str,
+  ) -> None:
+    super().initialize(mj_model, model, data, device)
+
+    num_envs = data.nworld
+    num_joints = len(self._target_names)
+    self.stiffness = torch.full(
+      (num_envs, num_joints), self.cfg.stiffness, dtype=torch.float, device=device
+    )
+    self.damping = torch.full(
+      (num_envs, num_joints), self.cfg.damping, dtype=torch.float, device=device
+    )
+    self.force_limit = torch.full(
+      (num_envs, num_joints), self.cfg.effort_limit, dtype=torch.float, device=device
+    )
+
+    self.default_stiffness = self.stiffness.clone()
+    self.default_damping = self.damping.clone()
+    self.default_force_limit = self.force_limit.clone()
+
+  def set_gains(
+    self,
+    env_ids: torch.Tensor | slice,
+    kp: torch.Tensor | None = None,
+    kd: torch.Tensor | None = None,
+  ) -> None:
+    """Set PD gains for specified environments.
+
+    Args:
+      env_ids: Environment indices to update.
+      kp: New proportional gains. Shape: (num_envs, num_actuators) or (num_envs,).
+      kd: New derivative gains. Shape: (num_envs, num_actuators) or (num_envs,).
+    """
+    assert self.stiffness is not None
+    assert self.damping is not None
+
+    if kp is not None:
+      if kp.ndim == 1:
+        kp = kp.unsqueeze(-1)
+      self.stiffness[env_ids] = kp
+
+    if kd is not None:
+      if kd.ndim == 1:
+        kd = kd.unsqueeze(-1)
+      self.damping[env_ids] = kd
+
+  def set_effort_limit(
+    self, env_ids: torch.Tensor | slice, effort_limit: torch.Tensor
+  ) -> None:
+    """Set effort limits for specified environments.
+
+    Args:
+      env_ids: Environment indices to update.
+      effort_limit: New effort limits. Shape: (num_envs, num_actuators) or (num_envs,).
+    """
+    assert self.force_limit is not None
+
+    if effort_limit.ndim == 1:
+      effort_limit = effort_limit.unsqueeze(-1)
+    self.force_limit[env_ids] = effort_limit
diff --git a/src/mjlab/actuator/xml_actuator.py b/src/mjlab/actuator/xml_actuator.py
new file mode 100644
index 0000000..98a04ef
--- /dev/null
+++ b/src/mjlab/actuator/xml_actuator.py
@@ -0,0 +1,132 @@
+"""Use actuators already defined in your robot XML.
+
+When your MJCF already has ``<position>``, ``<velocity>``, ``<motor>``, or ``<muscle>``
+elements, ``XmlActuatorCfg`` wraps them without re-specifying gains or limits. The
+actuator type is auto-detected from the spec element. Delay and other ``ActuatorCfg``
+fields work as usual.
+
+If your XML has actuators on both joints and tendons, use two configs with different
+``transmission_type`` values; a single config can only target one namespace.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, cast
+
+import mujoco
+import torch
+
+from mjlab.actuator.actuator import Actuator, ActuatorCfg, ActuatorCmd, CommandField
+from mjlab.utils.mujoco import detect_command_field
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+
+
+@dataclass(kw_only=True)
+class XmlActuatorCfg(ActuatorCfg):
+  """Wrap existing XML-defined actuators.
+
+  Detects the actuator type (position, velocity, motor, muscle) from the MuJoCo spec
+  element during ``edit_spec``, or validates against an explicit ``command_field`` if
+  provided.
+  """
+
+  command_field: CommandField | None = None
+  """If provided, require XML actuators to match this command field.
+  If None, auto-detect strictly from the spec element."""
+
+  def build(
+    self, entity: Entity, target_ids: list[int], target_names: list[str]
+  ) -> XmlActuator:
+    return XmlActuator(self, entity, target_ids, target_names)
+
+
+class XmlActuator(Actuator[XmlActuatorCfg]):
+  """Wrapper for XML-defined actuators."""
+
+  def __init__(
+    self,
+    cfg: XmlActuatorCfg,
+    entity: Entity,
+    target_ids: list[int],
+    target_names: list[str],
+  ) -> None:
+    super().__init__(cfg, entity, target_ids, target_names)
+    self._command_field: CommandField | None = None
+
+  @property
+  def command_field(self) -> CommandField:
+    """The resolved command field (detected or explicit), not the raw config value.
+
+    Set during ``edit_spec``. Use ``self.cfg.command_field`` to access the user's
+    original input (which may be None for auto-detection).
+    """
+    assert self._command_field is not None
+    return self._command_field
+
+  def edit_spec(self, spec: mujoco.MjSpec, target_names: list[str]) -> None:
+    # Filter to only targets that have corresponding XML actuators.
+    filtered_target_ids = []
+    filtered_target_names = []
+    for i, target_name in enumerate(target_names):
+      actuator = self._find_actuator_for_target(spec, target_name)
+      if actuator is not None:
+        self._mjs_actuators.append(actuator)
+        filtered_target_ids.append(self._target_ids_list[i])
+        # Store the user-facing (stripped) name, not the spec name.
+        filtered_target_names.append(self._target_names[i])
+
+    if len(filtered_target_names) == 0:
+      raise ValueError(
+        f"No XML actuators found for any targets matching the patterns. "
+        f"Searched targets: {target_names}. "
+        f"XML actuator config expects actuators to already exist in the XML."
+      )
+
+    # Update target IDs and names to only include those with actuators.
+    self._target_ids_list = filtered_target_ids
+    self._target_names = filtered_target_names
+
+    if self.cfg.command_field is not None:
+      # Validate that every matched actuator is compatible with the
+      # requested command field.
+      for act, name in zip(self._mjs_actuators, self._target_names, strict=True):
+        try:
+          detected = detect_command_field(act)
+        except ValueError:
+          continue  # Unrecognized type; trust the explicit override.
+        if detected != self.cfg.command_field:
+          raise ValueError(
+            f"XML actuator for '{name}' is type '{detected}', but "
+            f"command_field='{self.cfg.command_field}' was requested."
+          )
+      self._command_field = self.cfg.command_field
+    else:
+      # Auto-detect from spec elements. Raises for unrecognized types.
+      fields = [detect_command_field(a) for a in self._mjs_actuators]
+      unique = set(fields)
+      if len(unique) > 1:
+        breakdown = dict(zip(self._target_names, fields, strict=True))
+        raise ValueError(
+          f"Mixed XML actuator types for targets: {breakdown}. "
+          f"Split into separate XmlActuatorCfg groups."
+        )
+      self._command_field = cast(CommandField, fields[0])
+
+  def compute(self, cmd: ActuatorCmd) -> torch.Tensor:
+    if self._command_field == "position":
+      return cmd.position_target
+    if self._command_field == "velocity":
+      return cmd.velocity_target
+    return cmd.effort_target
+
+  def _find_actuator_for_target(
+    self, spec: mujoco.MjSpec, target_name: str
+  ) -> mujoco.MjsActuator | None:
+    """Find an actuator that targets the given target."""
+    for actuator in spec.actuators:
+      if actuator.target == target_name:
+        return actuator
+    return None
diff --git a/src/mjlab/asset_zoo/README.md b/src/mjlab/asset_zoo/README.md
new file mode 100644
index 0000000..24663cf
--- /dev/null
+++ b/src/mjlab/asset_zoo/README.md
@@ -0,0 +1,7 @@
+# Asset Zoo
+
+| Robot | Image |
+|-------|-------|
+| **Unitree G1** | <img src="../../../docs/source/_static/content/g1.png" width="200" height="150" alt="Unitree G1 Humanoid"> |
+| **Unitree Go1** | <img src="../../../docs/source/_static/content/go1.png" width="200" height="150" alt="Unitree Go1 Quadruped"> |
+| **i2rt YAM** | <img src="../../../docs/source/_static/content/yam.png" width="200" height="150" alt="i2rt YAM Robot Arm"> |
diff --git a/src/mjlab/asset_zoo/__init__.py b/src/mjlab/asset_zoo/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/mjlab/asset_zoo/robots/__init__.py b/src/mjlab/asset_zoo/robots/__init__.py
new file mode 100644
index 0000000..f855d96
--- /dev/null
+++ b/src/mjlab/asset_zoo/robots/__init__.py
@@ -0,0 +1,18 @@
+from mjlab.asset_zoo.robots.i2rt_yam.yam_constants import (
+  YAM_ACTION_SCALE as YAM_ACTION_SCALE,
+)
+from mjlab.asset_zoo.robots.i2rt_yam.yam_constants import (
+  get_yam_robot_cfg as get_yam_robot_cfg,
+)
+from mjlab.asset_zoo.robots.unitree_g1.g1_constants import (
+  G1_ACTION_SCALE as G1_ACTION_SCALE,
+)
+from mjlab.asset_zoo.robots.unitree_g1.g1_constants import (
+  get_g1_robot_cfg as get_g1_robot_cfg,
+)
+from mjlab.asset_zoo.robots.unitree_go1.go1_constants import (
+  GO1_ACTION_SCALE as GO1_ACTION_SCALE,
+)
+from mjlab.asset_zoo.robots.unitree_go1.go1_constants import (
+  get_go1_robot_cfg as get_go1_robot_cfg,
+)
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/__init__.py b/src/mjlab/asset_zoo/robots/i2rt_yam/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/d405.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/d405.stl
new file mode 100644
index 0000000..7504e2a
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/d405.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2.stl
new file mode 100644
index 0000000..d597a05
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__10.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__10.stl
new file mode 100644
index 0000000..b065de1
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__10.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__11.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__11.stl
new file mode 100644
index 0000000..736495b
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__11.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__12.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__12.stl
new file mode 100644
index 0000000..356322f
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__12.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__13.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__13.stl
new file mode 100644
index 0000000..41dcd97
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__13.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__14.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__14.stl
new file mode 100644
index 0000000..d5f7aa0
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__14.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__15.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__15.stl
new file mode 100644
index 0000000..28cabf6
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__15.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__16.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__16.stl
new file mode 100644
index 0000000..1b397ba
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__16.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__17.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__17.stl
new file mode 100644
index 0000000..c685929
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__17.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__2.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__2.stl
new file mode 100644
index 0000000..2d180f0
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__2.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__3.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__3.stl
new file mode 100644
index 0000000..89c512c
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__3.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__4.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__4.stl
new file mode 100644
index 0000000..7186d0f
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__4.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__5.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__5.stl
new file mode 100644
index 0000000..afd1996
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__5.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__6.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__6.stl
new file mode 100644
index 0000000..71fc6c2
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__6.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__7.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__7.stl
new file mode 100644
index 0000000..1aef9c1
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__7.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__8.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__8.stl
new file mode 100644
index 0000000..ad2475d
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__8.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__9.stl b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__9.stl
new file mode 100644
index 0000000..e6287e0
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/assets/model2__9.stl differ
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/yam.xml b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/yam.xml
new file mode 100644
index 0000000..08051bb
--- /dev/null
+++ b/src/mjlab/asset_zoo/robots/i2rt_yam/xmls/yam.xml
@@ -0,0 +1,184 @@
+<mujoco model="yam_v0">
+  <compiler angle="radian" meshdir="assets"/>
+
+  <default>
+    <default class="yam">
+      <site group="5" size="0.005" rgba="0 1 0 1"/>
+      <joint axis="0 0 1"/>
+      <default class="visual">
+        <geom type="mesh" contype="0" conaffinity="0" density="0" group="2" material="black"/>
+      </default>
+      <default class="collision">
+        <geom group="3" type="capsule"/>
+        <default class="sphere_collision">
+          <geom size="0.0006 0 0" type="sphere" rgba="1 0 0 1" group="4"/>
+        </default>
+      </default>
+      <default class="finger">
+        <joint type="slide"/>
+      </default>
+    </default>
+  </default>
+
+  <asset>
+    <material name="black" rgba="0.25 0.25 0.25 1"/>
+    <material name="white" rgba="0.9 0.9 0.9 1"/>
+
+    <mesh file="model2.stl"/>
+    <mesh file="model2__2.stl"/>
+    <mesh file="model2__3.stl"/>
+    <mesh file="model2__4.stl"/>
+    <mesh file="model2__5.stl"/>
+    <mesh file="model2__6.stl"/>
+    <mesh file="model2__7.stl"/>
+    <mesh file="model2__8.stl"/>
+    <mesh file="model2__9.stl"/>
+    <mesh file="model2__10.stl"/>
+    <mesh file="model2__11.stl"/>
+    <mesh file="model2__12.stl"/>
+    <mesh file="model2__13.stl"/>
+    <mesh file="model2__14.stl"/>
+    <mesh file="model2__15.stl"/>
+    <mesh file="model2__16.stl"/>
+    <mesh file="model2__17.stl"/>
+
+    <mesh name="camera_d405" file="d405.stl"/>
+  </asset>
+
+  <worldbody>
+    <light name="spotlight" mode="targetbodycom" target="link_6" pos="0 0 1"/>
+    <camera name="front_cam" pos="1.1 0 .5" xyaxes="0 1 0 -0.3 0 0.7"/>
+    <body name="arm" childclass="yam">
+      <geom class="visual" pos="0 0 -0.0006" quat="1 0 0 1" mesh="model2"/>
+      <geom name="base_collision" class="collision" size="0.033 0.01" pos="0.0 0.0 0.026" quat="1 0 0 0"/>
+      <body name="link_1" pos="0 0 0.0631" quat="1 0 0 1">
+        <inertial pos="-0.00192861 -0.00795735 0.0208176" quat="0.297851 0.642634 0.360045 0.607185" mass="0.12415"
+          diaginertia="0.000180751 0.000145532 5.89179e-05"/>
+        <joint name="joint1" range="-2.61799 3.05433"/>
+        <geom class="visual" pos="5.26159e-07 2.34355e-07 -0.0632" quat="1 0 0 0" mesh="model2__2"/>
+        <body name="link_2" pos="2.5e-05 -0.02 0.0409" quat="1 1 1 1">
+          <inertial pos="0.132008 2.10599e-06 0.000293073" quat="1 1 1 1" mass="1.24434"
+            diaginertia="0.0121902 0.0121318 0.000683304"/>
+          <joint name="joint2" range="0 3.66519"/>
+          <geom class="visual" pos="0.0199992 -0.1041 -2.44738e-05" quat="1 -1 -1 -1" mesh="model2__3"/>
+          <geom class="visual" pos="0.0199992 -0.1041 -2.44738e-05" quat="1 -1 -1 -1" mesh="model2__4"/>
+          <geom class="visual" pos="0.0199992 -0.1041 -2.44738e-05" quat="1 -1 -1 -1" mesh="model2__5" material="white"/>
+          <geom name="link2_1_collision" class="collision" size="0.032 0.11" pos="0.13 0 0" quat="1 0 1 0"/>
+          <geom name="link2_2_collision" class="collision" size="0.033 0.02" pos="0 0.0 0" quat="1 0 0 0"/>
+          <geom name="link2_3_collision" class="collision" size="0.033 0.025" pos="0.265 0 0" quat="1 0 0 0"/>
+          <body name="link_3" pos="0.264 0 0" quat="0 1 0 0">
+            <inertial pos="-0.121816 -0.054846 -0.000111108" quat="1 1 1 1" mass="0.853698"
+              diaginertia="0.00699732 0.00696112 0.000788244"/>
+            <joint name="joint3" range="0 3.66519"/>
+            <geom class="visual" pos="-0.244001 0.104101 2.44738e-05" quat="1 1 1 -1" mesh="model2__6"/>
+            <geom class="visual" pos="-0.244001 0.104101 2.44738e-05" quat="1 1 1 -1" mesh="model2__7"/>
+            <geom class="visual" pos="-0.244001 0.104101 2.44738e-05" quat="1 1 1 -1" mesh="model2__8" material="white"/>
+            <geom class="visual" pos="-0.244001 0.104101 2.44738e-05" quat="1 1 1 -1" mesh="model2__9"/>
+            <geom name="link3_1_collision" class="collision" size="0.034 0.12" pos="-0.14 -0.06 0.0" quat="1 0 1 0"/>
+            <geom name="link3_2_collision" class="collision" size="0.034 0.015" pos="-0.24 -0.06 0.0" quat="1 0 0 0"/>
+            <body name="link_4" pos="-0.245 -0.06 0" quat="1 0 0 0">
+              <inertial pos="-0.0769778 -0.0527104 0.000154878" quat="0.667 0.667 -0.236 -0.236" mass="0.463511"
+                diaginertia="0.000791532 0.000744733 0.000282116"/>
+              <joint name="joint4" range="-1.5708 1.5708"/>
+              <geom class="visual" pos="0.00100023 0.164101 2.44738e-05" quat="1 1 1 -1" mesh="model2__10"/>
+              <geom name="link4_1_collision" class="collision" size="0.03 0.015" pos="-0.073 -0.06 0.0" quat="1 1 0 0"/>
+              <body name="link_5" pos="-0.074 -0.0395 2.5e-05" quat="1 -1 1 1">
+                <inertial pos="3.64861e-05 0.00025665 0.0353526" quat="1 0 0 0" mass="0.350962"
+                  diaginertia="0.000197802 0.0001775 0.000147402"/>
+                <joint name="joint5" range="-1.5708 1.5708"/>
+                <geom class="visual" pos="0 -0.0749971 0.203601" quat="1.32679e-06 1 0 0" mesh="model2__11"/>
+                <geom name="link5_1_collision" class="collision" size="0.030 0.015" pos="0 0.025 0.0395" quat="1 1 0 0"/>
+                <body name="link_6" pos="0 0.0353 0.0395" quat="1 -1 0 0">
+                  <inertial pos="-0.000217767 7.37059e-05 0.0270545" quat="1 1 0 0" mass="0.367476"
+                    diaginertia="0.000265958 0.000242686 0.000227409"/>
+                  <joint name="joint6" range="-2.0944 2.0944"/>
+                  <geom class="visual" pos="0 -0.164101 -0.110597" quat="1 -1 0 0" mesh="model2__12"/>
+                  <geom class="visual" pos="0 -0.164101 -0.110597" quat="1 -1 0 0" mesh="model2__13"/>
+                  <geom name="link6_1_collision" class="collision" size="0.01 0.035" pos="0 0.039 0.052" quat="1 0 1 0"/>
+                  <geom name="link6_2_collision" class="collision" size="0.030 0.005" pos="0 0.0 0.03" quat="1 0 0 1"/>
+                  <geom name="link6_3_collision" class="collision" size="0.01 0.035" pos="0 -0.039 0.052" quat="1 0 1 0"/>
+                  <site name="tcp_site" quat="1 0 0 -1"/>
+                  <site name="grasp_site" pos="0 -0.03 0.1247" quat="1 0 0 -1"/>
+                  <body name="link_left_finger" pos="-0.037 0.0392 0.0605" quat="1 0 1 0">
+                    <inertial pos="-0.0192995 -0.0365902 0.039774" quat="0.757351 0.568898 -0.3199 0.0" mass="0.118"
+                      diaginertia="0.000159084 0.000154909 4.63655e-05"/>
+                    <joint class="finger" name="left_finger" range="-0.00205 0.037524"/>
+                    <geom class="visual" pos="0.171097 -0.203301 0.037" quat="1 -1 -1 -1" mesh="model2__14"/>
+                    <geom class="visual" pos="0.171097 -0.203301 0.037" quat="1 -1 -1 -1" mesh="model2__15"/>
+                    <body name="lf_rot" quat="1 -1 -1 1" pos="0.0 -0.0392 0.037">
+                      <geom name="lf_rot1_collision" class="collision" size="0.01 0.03" pos="0.0 -0.02 0.012"
+                        quat="1 0 1 0" rgba="0.381493 0.492734 0.780446 1"/>
+                      <geom name="lf_rot2_collision" class="collision" size="0.01 0.02" pos="-0.02 -0.01 0.032"
+                        quat="1 0 2.5 0" rgba="0.381493 0.492734 0.780446 1"/>
+                      <body name="lf_down" quat="1 0 0 0" pos="-0.044 0.0 0.0">
+                        <geom name="lf_down1_collision" class="collision" size="0.01 0.01" pos="0.0 -0.020 0.012"
+                          quat="1 -0.1 0 0" rgba="0.381493 0.492734 0.780446 1"/>
+                        <geom name="lf_down2_collision" class="collision" size="0.003 0.022" pos="0.005 -0.014 0.04"
+                          quat="1 -0.2 0 0" rgba="0.381493 0.492734 0.780446 1"/>
+                        <geom name="lf_down3_collision" class="collision" size="0.003 0.022" pos="-0.005 -0.014 0.04"
+                          quat="1 -0.2 0 0" rgba="0.381493 0.492734 0.780446 1"/>
+                        <geom name="lf_down4_collision" class="collision" type="box" size="0.006 0.002 0.04"
+                          pos="0 -0.0024 0.046" quat="1 0 0 0" rgba="0.381493 0.492734 0.780446 1"/>
+                        <geom name="lf_down5_collision" class="collision" type="box" size="0.006 0.002 0.039"
+                          pos="0.027 -0.0024 0.053" quat="1 0 2.5 0" rgba="0.381493 0.492734 0.780446 1"/>
+                        <geom name="lf_down6_collision" class="sphere_collision" pos="0.003  -0.0004 0.078"/>
+                        <geom name="lf_down7_collision" class="sphere_collision" pos="-0.003 -0.0004 0.078"/>
+                        <geom name="lf_down8_collision" class="sphere_collision" pos="0.003  -0.0004 0.07"/>
+                        <geom name="lf_down9_collision" class="sphere_collision" pos="-0.003 -0.0004 0.07"/>
+                        <geom name="lf_down10_collision" class="sphere_collision" pos="0.003  -0.0004 0.06"/>
+                        <geom name="lf_down11_collision" class="sphere_collision" pos="-0.003 -0.0004 0.06"/>
+                      </body>
+                    </body>
+                  </body>
+                  <body name="camera_d405" pos="-0.0107 0.079729 0.066021" quat="0.953717 0.3007058 0 0">
+                    <geom class="visual" mesh="camera_d405"/>
+                    <geom class="collision" type="box" size=".018 .018 .01" pos="0 0 -0.01" group="4"/>
+                    <body name="camera_frame" pos="0.009 0 0" quat="0 0 0 1">
+                      <camera name="camera_d405" pos="0 0 0" quat="0 1 0 0" resolution="1280 720"
+                        sensorsize="0.003896 0.00214" focal="0.00193 0.00193"/>
+                    </body>
+                  </body>
+                  <body name="link_right_finger" pos="0.037 -0.0392 0.0605" quat="1 0 1 0">
+                    <inertial pos="-0.0192995 0.0365902 -0.039774" quat="-0.757351 0.568898 -0.3199 0" mass="0.118"
+                      diaginertia="0.000159084 0.000154909 4.63655e-05"/>
+                    <joint class="finger" name="right_finger" range="-0.037524 0.00205"/>
+                    <geom class="visual" pos="0.171097 -0.124901 -0.037" quat="1 -1 -1 -1" mesh="model2__16"/>
+                    <geom class="visual" pos="0.171097 -0.124901 -0.037" quat="1 -1 -1 -1" mesh="model2__17"/>
+                    <body name="rf_rot" quat="1 1 -1 -1" pos="0.0 0.0392 -0.037">
+                      <geom name="rf_rot1_collision" class="collision" size="0.01 0.03" pos="0.0 -0.02 0.012"
+                        quat="1 0 1 0" rgba="0.381493 0.492734 0.780446 1"/>
+                      <geom name="rf_rot2_collision" class="collision" size="0.01 0.02" pos="0.02 -0.01 0.032"
+                        quat="1 0 -2.5 0" rgba="0.381493 0.492734 0.780446 1"/>
+                      <body name="rf_down" quat="1 0 0 0" pos="0.044 0.0 0.0">
+                        <geom name="rf_down1_collision" class="collision" size="0.01 0.01" pos="0.0 -0.020 0.012"
+                          quat="1 -0.1 0 0" rgba="0.381493 0.492734 0.780446 1"/>
+                        <geom name="rf_down2_collision" class="collision" size="0.003 0.022" pos="0.005 -0.014 0.04"
+                          quat="1 -0.2 0 0" rgba="0.381493 0.492734 0.780446 1"/>
+                        <geom name="rf_down3_collision" class="collision" size="0.003 0.022" pos="-0.005 -0.014 0.04"
+                          quat="1 -0.2 0 0" rgba="0.381493 0.492734 0.780446 1"/>
+                        <geom name="rf_down4_collision" class="collision" type="box" size="0.006 0.002 0.04"
+                          pos="0 -0.0024 0.046" quat="1 0 0 0" rgba="0.381493 0.492734 0.780446 1"/>
+                        <geom name="rf_down5_collision" class="collision" type="box" size="0.006 0.002 0.039"
+                          pos="-0.027 -0.0024 0.053" quat="1 0 -2.5 0" rgba="0.381493 0.492734 0.780446 1"/>
+                        <geom name="rf_down6_collision" class="sphere_collision" pos="0.003 -0.0004 0.078"/>
+                        <geom name="rf_down7_collision" class="sphere_collision" pos="-0.003 -0.0004 0.078"/>
+                        <geom name="rf_down8_collision" class="sphere_collision" pos="0.003  -0.0004 0.07"/>
+                        <geom name="rf_down9_collision" class="sphere_collision" pos="-0.003 -0.0004 0.07"/>
+                        <geom name="rf_down10_collision" class="sphere_collision" pos="0.003 -0.0004 0.06"/>
+                        <geom name="rf_down11_collision" class="sphere_collision" pos="-0.003 -0.0004 0.06"/>
+                      </body>
+                    </body>
+                  </body>
+                </body>
+              </body>
+            </body>
+          </body>
+        </body>
+      </body>
+    </body>
+  </worldbody>
+
+  <equality>
+    <joint joint1="left_finger" joint2="right_finger" polycoef="0 -1 0 0 0"/>
+  </equality>
+</mujoco>
diff --git a/src/mjlab/asset_zoo/robots/i2rt_yam/yam_constants.py b/src/mjlab/asset_zoo/robots/i2rt_yam/yam_constants.py
new file mode 100644
index 0000000..b9872f1
--- /dev/null
+++ b/src/mjlab/asset_zoo/robots/i2rt_yam/yam_constants.py
@@ -0,0 +1,236 @@
+"""YAM constants."""
+
+from pathlib import Path
+
+import mujoco
+
+from mjlab import MJLAB_SRC_PATH
+from mjlab.actuator import BuiltinPositionActuatorCfg
+from mjlab.entity import EntityArticulationInfoCfg, EntityCfg
+from mjlab.utils.actuator import (
+  ElectricActuator,
+  reflect_rotary_to_linear,
+)
+from mjlab.utils.spec_config import CollisionCfg
+
+##
+# MJCF and assets.
+##
+
+YAM_XML: Path = (
+  MJLAB_SRC_PATH / "asset_zoo" / "robots" / "i2rt_yam" / "xmls" / "yam.xml"
+)
+assert YAM_XML.exists()
+
+
+def get_spec() -> mujoco.MjSpec:
+  return mujoco.MjSpec.from_file(str(YAM_XML))
+
+
+##
+# Actuator config.
+##
+
+EFFECTIVE_INERTIAS = {
+  "joint1": 0.123153,
+  "joint2": 0.277411,
+  "joint3": 0.232763,
+  "joint4": 0.030154,
+  "joint5": 0.009126,
+  "joint6": 0.002868,
+  "left_finger": 2.781624,
+}
+
+ARMATURE_DM_4340 = 0.032
+ARMATURE_DM_4310 = 0.0018
+
+# Reference: https://github.com/i2rt-robotics/i2rt/blob/cbe48976b44aae45af856c62545be00ea2feed11/i2rt/motor_drivers/utils.py#L159-L169
+DM_4340 = ElectricActuator(
+  reflected_inertia=ARMATURE_DM_4340,
+  velocity_limit=10.0,
+  effort_limit=28.0,
+)
+# Reference: https://github.com/i2rt-robotics/i2rt/blob/cbe48976b44aae45af856c62545be00ea2feed11/i2rt/motor_drivers/utils.py#L139-L149
+DM_4310 = ElectricActuator(
+  reflected_inertia=ARMATURE_DM_4310,
+  velocity_limit=30.0,
+  effort_limit=10.0,
+)
+
+NATURAL_FREQ = 2 * 2.0 * 3.1415926535  # 2Hz
+DAMPING_RATIO = 2.0
+
+# Per-joint PD gains using effective inertia, and actuator configs.
+_ARM_JOINTS: dict[str, ElectricActuator] = {
+  "joint1": DM_4340,
+  "joint2": DM_4340,
+  "joint3": DM_4340,
+  "joint4": DM_4310,
+  "joint5": DM_4310,
+  "joint6": DM_4310,
+}
+ARM_ACTUATORS = tuple(
+  BuiltinPositionActuatorCfg(
+    target_names_expr=(name,),
+    stiffness=EFFECTIVE_INERTIAS[name] * NATURAL_FREQ**2,
+    damping=2.0 * DAMPING_RATIO * EFFECTIVE_INERTIAS[name] * NATURAL_FREQ,
+    effort_limit=motor.effort_limit,
+    armature=motor.reflected_inertia,
+  )
+  for name, motor in _ARM_JOINTS.items()
+)
+
+##
+# Gripper transmission parameters.
+##
+
+# Reference: https://github.com/i2rt-robotics/i2rt/blob/cbe48976b44aae45af856c62545be00ea2feed11/i2rt/robots/utils.py#L106-L118
+
+# Crank gripper: DM 4310 drives a crank arm that converts rotation to linear motion.
+# The mechanism geometry (8° to 170°) provides 71mm stroke, but we operate over
+# 10° to 165° (2.7 rad motor range) for safety, giving ~70mm usable stroke.
+# Note: Transmission ratio varies with position as r(θ) = r_crank*sin(θ); we use
+# an effective average (dx/dθ) for simulation.
+GRIPPER_MOTOR_STROKE_CRANK = 2.7  # [rad]: operational motor range (from limits)
+GRIPPER_LINEAR_STROKE_CRANK = 0.071  # [m]: design stroke (full mechanism range)
+GRIPPER_TRANSMISSION_RATIO_CRANK = (
+  GRIPPER_LINEAR_STROKE_CRANK / GRIPPER_MOTOR_STROKE_CRANK
+)
+
+# Reflect motor properties to linear gripper joint.
+(
+  ARMATURE_DM_4310_LINEAR_CRANK,
+  VELOCITY_LIMIT_DM_4310_LINEAR_CRANK,
+  EFFORT_LIMIT_DM_4310_LINEAR_CRANK,
+) = reflect_rotary_to_linear(
+  armature_rotary=ARMATURE_DM_4310,
+  velocity_limit_rotary=DM_4310.velocity_limit,
+  effort_limit_rotary=DM_4310.effort_limit,
+  transmission_ratio=GRIPPER_TRANSMISSION_RATIO_CRANK,
+)
+
+# PD controller gains using effective inertia.
+NATURAL_FREQ_GRIPPER = 1.0 * 2.0 * 3.1415926535  # 1Hz
+STIFFNESS_GRIPPER = EFFECTIVE_INERTIAS["left_finger"] * NATURAL_FREQ_GRIPPER**2
+DAMPING_GRIPPER = (
+  2.0 * DAMPING_RATIO * EFFECTIVE_INERTIAS["left_finger"] * NATURAL_FREQ_GRIPPER
+)
+
+# Artificially limit gripper force for sim stability (must also be done on hardware).
+EFFORT_LIMIT_DM_4310_LINEAR_CRANK_SAFE = EFFORT_LIMIT_DM_4310_LINEAR_CRANK * 0.1
+
+# Only actuate left_finger; right_finger is coupled via equality constraint.
+ACTUATOR_DM_4310_LINEAR_CRANK = BuiltinPositionActuatorCfg(
+  target_names_expr=("left_finger",),
+  stiffness=STIFFNESS_GRIPPER,
+  damping=DAMPING_GRIPPER,
+  effort_limit=EFFORT_LIMIT_DM_4310_LINEAR_CRANK_SAFE,
+  armature=ARMATURE_DM_4310_LINEAR_CRANK,
+)
+
+##
+# Keyframe config.
+##
+
+HOME_KEYFRAME = EntityCfg.InitialStateCfg(
+  pos=(0.0, 0.0, 0.01),
+  joint_pos={
+    "joint2": 1.047,
+    "joint3": 1.05,
+    "joint4": -0.9,
+    "left_finger": 0.0375 / 2,
+    "right_finger": -0.0375 / 2,
+  },
+  joint_vel={".*": 0.0},
+)
+
+##
+# Collision config.
+##
+
+FULL_COLLISION = CollisionCfg(
+  geom_names_expr=(".*_collision",),
+  contype=1,
+  conaffinity=1,
+  condim={
+    "[lr]f_down(6|7|8|9|10|11)_collision": 6,
+    ".*_collision": 3,
+  },
+  friction={
+    "[lr]f_down(6|7|8|9|10|11)_collision": (1, 5e-3, 5e-4),
+    ".*_collision": (0.6,),
+  },
+  solref={
+    "[lr]f_down(6|7|8|9|10|11)_collision": (0.01, 1),
+  },
+  priority={
+    "[lr]f_down(6|7|8|9|10|11)_collision": 1,
+    ".*": 0,
+  },
+)
+
+GRIPPER_ONLY_COLLISION = CollisionCfg(
+  geom_names_expr=(".*_collision",),
+  contype={
+    "(link6|[lr]f)_.*_collision": 1,
+    ".*_collision": 0,
+  },
+  conaffinity={
+    "(link6|[lr]f)_.*_collision": 1,
+    ".*_collision": 0,
+  },
+  condim={
+    "[lr]f_down(6|7|8|9|10|11)_collision": 6,
+    ".*_collision": 3,
+  },
+  friction={
+    "[lr]f_down(6|7|8|9|10|11)_collision": (1, 5e-3, 5e-4),
+    ".*_collision": (0.6,),
+  },
+  solref={
+    "[lr]f_down(6|7|8|9|10|11)_collision": (0.01, 1),
+  },
+  priority={
+    "[lr]f_down(6|7|8|9|10|11)_collision": 1,
+    ".*": 0,
+  },
+)
+
+##
+# Final config.
+##
+
+ARTICULATION = EntityArticulationInfoCfg(
+  actuators=(*ARM_ACTUATORS, ACTUATOR_DM_4310_LINEAR_CRANK),
+  soft_joint_pos_limit_factor=0.9,
+)
+
+
+def get_yam_robot_cfg() -> EntityCfg:
+  return EntityCfg(
+    init_state=HOME_KEYFRAME,
+    collisions=(GRIPPER_ONLY_COLLISION,),
+    spec_fn=get_spec,
+    articulation=ARTICULATION,
+  )
+
+
+YAM_ACTION_SCALE: dict[str, float] = {}
+for a in ARTICULATION.actuators:
+  assert isinstance(a, BuiltinPositionActuatorCfg)
+  e = a.effort_limit
+  s = a.stiffness
+  names = a.target_names_expr
+  assert e is not None
+  for n in names:
+    YAM_ACTION_SCALE[n] = 0.25 * e / s
+
+
+if __name__ == "__main__":
+  import mujoco.viewer as viewer
+
+  from mjlab.entity.entity import Entity
+
+  robot = Entity(get_yam_robot_cfg())
+
+  viewer.launch(robot.spec.compile())
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/__init__.py b/src/mjlab/asset_zoo/robots/unitree_g1/__init__.py
new file mode 100644
index 0000000..3ebf37d
--- /dev/null
+++ b/src/mjlab/asset_zoo/robots/unitree_g1/__init__.py
@@ -0,0 +1 @@
+"""Unitree G1 humanoid."""
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/g1_constants.py b/src/mjlab/asset_zoo/robots/unitree_g1/g1_constants.py
new file mode 100644
index 0000000..76aaef4
--- /dev/null
+++ b/src/mjlab/asset_zoo/robots/unitree_g1/g1_constants.py
@@ -0,0 +1,298 @@
+"""Unitree G1 constants."""
+
+from pathlib import Path
+
+import mujoco
+
+from mjlab import MJLAB_SRC_PATH
+from mjlab.actuator import BuiltinPositionActuatorCfg
+from mjlab.entity import EntityArticulationInfoCfg, EntityCfg
+from mjlab.utils.actuator import (
+  ElectricActuator,
+  reflected_inertia_from_two_stage_planetary,
+)
+from mjlab.utils.spec_config import CollisionCfg
+
+##
+# MJCF and assets.
+##
+
+G1_XML: Path = (
+  MJLAB_SRC_PATH / "asset_zoo" / "robots" / "unitree_g1" / "xmls" / "g1.xml"
+)
+assert G1_XML.exists()
+
+
+def get_spec() -> mujoco.MjSpec:
+  return mujoco.MjSpec.from_file(str(G1_XML))
+
+
+##
+# Actuator config.
+##
+
+# Motor specs (from Unitree).
+ROTOR_INERTIAS_5020 = (
+  0.139e-4,
+  0.017e-4,
+  0.169e-4,
+)
+GEARS_5020 = (
+  1,
+  1 + (46 / 18),
+  1 + (56 / 16),
+)
+ARMATURE_5020 = reflected_inertia_from_two_stage_planetary(
+  ROTOR_INERTIAS_5020, GEARS_5020
+)
+
+ROTOR_INERTIAS_7520_14 = (
+  0.489e-4,
+  0.098e-4,
+  0.533e-4,
+)
+GEARS_7520_14 = (
+  1,
+  4.5,
+  1 + (48 / 22),
+)
+ARMATURE_7520_14 = reflected_inertia_from_two_stage_planetary(
+  ROTOR_INERTIAS_7520_14, GEARS_7520_14
+)
+
+ROTOR_INERTIAS_7520_22 = (
+  0.489e-4,
+  0.109e-4,
+  0.738e-4,
+)
+GEARS_7520_22 = (
+  1,
+  4.5,
+  5,
+)
+ARMATURE_7520_22 = reflected_inertia_from_two_stage_planetary(
+  ROTOR_INERTIAS_7520_22, GEARS_7520_22
+)
+
+ROTOR_INERTIAS_4010 = (
+  0.068e-4,
+  0.0,
+  0.0,
+)
+GEARS_4010 = (
+  1,
+  5,
+  5,
+)
+ARMATURE_4010 = reflected_inertia_from_two_stage_planetary(
+  ROTOR_INERTIAS_4010, GEARS_4010
+)
+
+ACTUATOR_5020 = ElectricActuator(
+  reflected_inertia=ARMATURE_5020,
+  velocity_limit=37.0,
+  effort_limit=25.0,
+)
+ACTUATOR_7520_14 = ElectricActuator(
+  reflected_inertia=ARMATURE_7520_14,
+  velocity_limit=32.0,
+  effort_limit=88.0,
+)
+ACTUATOR_7520_22 = ElectricActuator(
+  reflected_inertia=ARMATURE_7520_22,
+  velocity_limit=20.0,
+  effort_limit=139.0,
+)
+ACTUATOR_4010 = ElectricActuator(
+  reflected_inertia=ARMATURE_4010,
+  velocity_limit=22.0,
+  effort_limit=5.0,
+)
+
+NATURAL_FREQ = 10 * 2.0 * 3.1415926535  # 10Hz
+DAMPING_RATIO = 2.0
+
+STIFFNESS_5020 = ARMATURE_5020 * NATURAL_FREQ**2
+STIFFNESS_7520_14 = ARMATURE_7520_14 * NATURAL_FREQ**2
+STIFFNESS_7520_22 = ARMATURE_7520_22 * NATURAL_FREQ**2
+STIFFNESS_4010 = ARMATURE_4010 * NATURAL_FREQ**2
+
+DAMPING_5020 = 2.0 * DAMPING_RATIO * ARMATURE_5020 * NATURAL_FREQ
+DAMPING_7520_14 = 2.0 * DAMPING_RATIO * ARMATURE_7520_14 * NATURAL_FREQ
+DAMPING_7520_22 = 2.0 * DAMPING_RATIO * ARMATURE_7520_22 * NATURAL_FREQ
+DAMPING_4010 = 2.0 * DAMPING_RATIO * ARMATURE_4010 * NATURAL_FREQ
+
+G1_ACTUATOR_5020 = BuiltinPositionActuatorCfg(
+  target_names_expr=(
+    ".*_elbow_joint",
+    ".*_shoulder_pitch_joint",
+    ".*_shoulder_roll_joint",
+    ".*_shoulder_yaw_joint",
+    ".*_wrist_roll_joint",
+  ),
+  stiffness=STIFFNESS_5020,
+  damping=DAMPING_5020,
+  effort_limit=ACTUATOR_5020.effort_limit,
+  armature=ACTUATOR_5020.reflected_inertia,
+)
+G1_ACTUATOR_7520_14 = BuiltinPositionActuatorCfg(
+  target_names_expr=(".*_hip_pitch_joint", ".*_hip_yaw_joint", "waist_yaw_joint"),
+  stiffness=STIFFNESS_7520_14,
+  damping=DAMPING_7520_14,
+  effort_limit=ACTUATOR_7520_14.effort_limit,
+  armature=ACTUATOR_7520_14.reflected_inertia,
+)
+G1_ACTUATOR_7520_22 = BuiltinPositionActuatorCfg(
+  target_names_expr=(".*_hip_roll_joint", ".*_knee_joint"),
+  stiffness=STIFFNESS_7520_22,
+  damping=DAMPING_7520_22,
+  effort_limit=ACTUATOR_7520_22.effort_limit,
+  armature=ACTUATOR_7520_22.reflected_inertia,
+)
+G1_ACTUATOR_4010 = BuiltinPositionActuatorCfg(
+  target_names_expr=(".*_wrist_pitch_joint", ".*_wrist_yaw_joint"),
+  stiffness=STIFFNESS_4010,
+  damping=DAMPING_4010,
+  effort_limit=ACTUATOR_4010.effort_limit,
+  armature=ACTUATOR_4010.reflected_inertia,
+)
+
+# Waist pitch/roll and ankles are 4-bar linkages with 2 5020 actuators.
+# Due to the parallel linkage, the effective armature at the ankle and waist joints
+# is configuration dependent. Since the exact geometry of the linkage is unknown, we
+# assume a nominal 1:1 gear ratio. Under this assumption, the joint armature in the
+# nominal configuration is approximated as the sum of the 2 actuators' armatures.
+G1_ACTUATOR_WAIST = BuiltinPositionActuatorCfg(
+  target_names_expr=("waist_pitch_joint", "waist_roll_joint"),
+  stiffness=STIFFNESS_5020 * 2,
+  damping=DAMPING_5020 * 2,
+  effort_limit=ACTUATOR_5020.effort_limit * 2,
+  armature=ACTUATOR_5020.reflected_inertia * 2,
+)
+G1_ACTUATOR_ANKLE = BuiltinPositionActuatorCfg(
+  target_names_expr=(".*_ankle_pitch_joint", ".*_ankle_roll_joint"),
+  stiffness=STIFFNESS_5020 * 2,
+  damping=DAMPING_5020 * 2,
+  effort_limit=ACTUATOR_5020.effort_limit * 2,
+  armature=ACTUATOR_5020.reflected_inertia * 2,
+)
+
+##
+# Keyframe config.
+##
+
+HOME_KEYFRAME = EntityCfg.InitialStateCfg(
+  pos=(0, 0, 0.783675),
+  joint_pos={
+    ".*_hip_pitch_joint": -0.1,
+    ".*_knee_joint": 0.3,
+    ".*_ankle_pitch_joint": -0.2,
+    ".*_shoulder_pitch_joint": 0.2,
+    ".*_elbow_joint": 1.28,
+    "left_shoulder_roll_joint": 0.2,
+    "right_shoulder_roll_joint": -0.2,
+  },
+  joint_vel={".*": 0.0},
+)
+
+KNEES_BENT_KEYFRAME = EntityCfg.InitialStateCfg(
+  pos=(0, 0, 0.76),
+  joint_pos={
+    ".*_hip_pitch_joint": -0.312,
+    ".*_knee_joint": 0.669,
+    ".*_ankle_pitch_joint": -0.363,
+    ".*_elbow_joint": 0.6,
+    "left_shoulder_roll_joint": 0.2,
+    "left_shoulder_pitch_joint": 0.2,
+    "right_shoulder_roll_joint": -0.2,
+    "right_shoulder_pitch_joint": 0.2,
+  },
+  joint_vel={".*": 0.0},
+)
+
+##
+# Collision config.
+##
+
+# This enables all collisions, including self collisions.
+# Self-collisions are given condim=1 while foot collisions
+# are given condim=3.
+FULL_COLLISION = CollisionCfg(
+  geom_names_expr=(".*_collision",),
+  contype=1,
+  conaffinity=1,
+  condim={r"^(left|right)_foot[1-7]_collision$": 3, ".*_collision": 1},
+  priority={r"^(left|right)_foot[1-7]_collision$": 1, ".*": 0},
+  friction={r"^(left|right)_foot[1-7]_collision$": (0.6,)},
+)
+
+FULL_COLLISION_WITHOUT_SELF = CollisionCfg(
+  geom_names_expr=(".*_collision",),
+  contype=0,
+  conaffinity=1,
+  condim={r"^(left|right)_foot[1-7]_collision$": 3, ".*_collision": 1},
+  priority={r"^(left|right)_foot[1-7]_collision$": 1, ".*": 0},
+  friction={r"^(left|right)_foot[1-7]_collision$": (0.6,)},
+)
+
+# This disables all collisions except the feet.
+# Feet get condim=3, all other geoms are disabled.
+FEET_ONLY_COLLISION = CollisionCfg(
+  geom_names_expr=(r"^(left|right)_foot[1-7]_collision$",),
+  contype=0,
+  conaffinity=1,
+  condim=3,
+  priority=1,
+  friction=(0.6,),
+)
+
+##
+# Final config.
+##
+
+G1_ARTICULATION = EntityArticulationInfoCfg(
+  actuators=(
+    G1_ACTUATOR_5020,
+    G1_ACTUATOR_7520_14,
+    G1_ACTUATOR_7520_22,
+    G1_ACTUATOR_4010,
+    G1_ACTUATOR_WAIST,
+    G1_ACTUATOR_ANKLE,
+  ),
+  soft_joint_pos_limit_factor=0.9,
+)
+
+
+def get_g1_robot_cfg() -> EntityCfg:
+  """Get a fresh G1 robot configuration instance.
+
+  Returns a new EntityCfg instance each time to avoid mutation issues when
+  the config is shared across multiple places.
+  """
+  return EntityCfg(
+    init_state=KNEES_BENT_KEYFRAME,
+    collisions=(FULL_COLLISION,),
+    spec_fn=get_spec,
+    articulation=G1_ARTICULATION,
+  )
+
+
+G1_ACTION_SCALE: dict[str, float] = {}
+for a in G1_ARTICULATION.actuators:
+  assert isinstance(a, BuiltinPositionActuatorCfg)
+  e = a.effort_limit
+  s = a.stiffness
+  names = a.target_names_expr
+  assert e is not None
+  for n in names:
+    G1_ACTION_SCALE[n] = 0.25 * e / s
+
+
+if __name__ == "__main__":
+  import mujoco.viewer as viewer
+
+  from mjlab.entity.entity import Entity
+
+  robot = Entity(get_g1_robot_cfg())
+
+  viewer.launch(robot.spec.compile())
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/head_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/head_link.STL
new file mode 100644
index 0000000..2ee5fba
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/head_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_ankle_pitch_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_ankle_pitch_link.STL
new file mode 100644
index 0000000..69de849
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_ankle_pitch_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_ankle_roll_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_ankle_roll_link.STL
new file mode 100644
index 0000000..8864e9f
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_ankle_roll_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_elbow_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_elbow_link.STL
new file mode 100644
index 0000000..1a96d99
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_elbow_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_hip_pitch_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_hip_pitch_link.STL
new file mode 100644
index 0000000..5b751c7
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_hip_pitch_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_hip_roll_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_hip_roll_link.STL
new file mode 100644
index 0000000..778437f
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_hip_roll_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_hip_yaw_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_hip_yaw_link.STL
new file mode 100644
index 0000000..383093a
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_hip_yaw_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_knee_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_knee_link.STL
new file mode 100644
index 0000000..f2e98e5
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_knee_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_rubber_hand.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_rubber_hand.STL
new file mode 100644
index 0000000..c44830f
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_rubber_hand.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_shoulder_pitch_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_shoulder_pitch_link.STL
new file mode 100644
index 0000000..e698311
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_shoulder_pitch_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_shoulder_roll_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_shoulder_roll_link.STL
new file mode 100644
index 0000000..80bca84
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_shoulder_roll_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_shoulder_yaw_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_shoulder_yaw_link.STL
new file mode 100644
index 0000000..281e699
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_shoulder_yaw_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_wrist_pitch_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_wrist_pitch_link.STL
new file mode 100644
index 0000000..82cc224
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_wrist_pitch_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_wrist_roll_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_wrist_roll_link.STL
new file mode 100644
index 0000000..f3c263a
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_wrist_roll_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_wrist_yaw_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_wrist_yaw_link.STL
new file mode 100644
index 0000000..31be4fd
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/left_wrist_yaw_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/logo_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/logo_link.STL
new file mode 100644
index 0000000..e979209
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/logo_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/pelvis.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/pelvis.STL
new file mode 100644
index 0000000..691a779
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/pelvis.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/pelvis_contour_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/pelvis_contour_link.STL
new file mode 100644
index 0000000..4243433
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/pelvis_contour_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_ankle_pitch_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_ankle_pitch_link.STL
new file mode 100644
index 0000000..e77d8a2
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_ankle_pitch_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_ankle_roll_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_ankle_roll_link.STL
new file mode 100644
index 0000000..d4261dd
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_ankle_roll_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_elbow_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_elbow_link.STL
new file mode 100644
index 0000000..f259e38
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_elbow_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_hip_pitch_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_hip_pitch_link.STL
new file mode 100644
index 0000000..998a0a0
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_hip_pitch_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_hip_roll_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_hip_roll_link.STL
new file mode 100644
index 0000000..47b2eeb
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_hip_roll_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_hip_yaw_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_hip_yaw_link.STL
new file mode 100644
index 0000000..3718564
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_hip_yaw_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_knee_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_knee_link.STL
new file mode 100644
index 0000000..76d21a3
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_knee_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_rubber_hand.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_rubber_hand.STL
new file mode 100644
index 0000000..0aacffb
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_rubber_hand.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_shoulder_pitch_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_shoulder_pitch_link.STL
new file mode 100644
index 0000000..3f5b4ed
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_shoulder_pitch_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_shoulder_roll_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_shoulder_roll_link.STL
new file mode 100644
index 0000000..179d617
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_shoulder_roll_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_shoulder_yaw_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_shoulder_yaw_link.STL
new file mode 100644
index 0000000..2ba6076
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_shoulder_yaw_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_wrist_pitch_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_wrist_pitch_link.STL
new file mode 100644
index 0000000..da19454
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_wrist_pitch_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_wrist_roll_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_wrist_roll_link.STL
new file mode 100644
index 0000000..26868d2
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_wrist_roll_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_wrist_yaw_link.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_wrist_yaw_link.STL
new file mode 100644
index 0000000..d788902
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/right_wrist_yaw_link.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/torso_link_rev_1_0.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/torso_link_rev_1_0.STL
new file mode 100644
index 0000000..8a759a7
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/torso_link_rev_1_0.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/waist_roll_link_rev_1_0.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/waist_roll_link_rev_1_0.STL
new file mode 100644
index 0000000..a64f330
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/waist_roll_link_rev_1_0.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/waist_yaw_link_rev_1_0.STL b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/waist_yaw_link_rev_1_0.STL
new file mode 100644
index 0000000..0fabb63
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/assets/waist_yaw_link_rev_1_0.STL differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_g1/xmls/g1.xml b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/g1.xml
new file mode 100644
index 0000000..dda4779
--- /dev/null
+++ b/src/mjlab/asset_zoo/robots/unitree_g1/xmls/g1.xml
@@ -0,0 +1,308 @@
+<mujoco model="g1_29dof_rev_1_0">
+  <compiler angle="radian" meshdir="assets" autolimits="true"/>
+
+  <default>
+    <default class="g1">
+      <default class="visual">
+        <geom group="2" type="mesh" density="0" material="silver" contype="0" conaffinity="0"/>
+      </default>
+      <default class="collision">
+        <geom group="3" rgba=".2 .6 .2 .3" type="capsule" contype="1" conaffinity="1"/>
+        <default class="foot_capsule">
+          <geom type="capsule" size="0.01"/>
+        </default>
+      </default>
+      <site group="5" rgba="1 0 0 1"/>
+    </default>
+  </default>
+
+  <asset>
+    <material name="silver" rgba="0.7 0.7 0.7 1"/>
+    <material name="black" rgba="0.2 0.2 0.2 1"/>
+
+    <mesh name="pelvis" file="pelvis.STL"/>
+    <mesh name="pelvis_contour_link" file="pelvis_contour_link.STL"/>
+    <mesh name="left_hip_pitch_link" file="left_hip_pitch_link.STL"/>
+    <mesh name="left_hip_roll_link" file="left_hip_roll_link.STL"/>
+    <mesh name="left_hip_yaw_link" file="left_hip_yaw_link.STL"/>
+    <mesh name="left_knee_link" file="left_knee_link.STL"/>
+    <mesh name="left_ankle_pitch_link" file="left_ankle_pitch_link.STL"/>
+    <mesh name="left_ankle_roll_link" file="left_ankle_roll_link.STL"/>
+    <mesh name="right_hip_pitch_link" file="right_hip_pitch_link.STL"/>
+    <mesh name="right_hip_roll_link" file="right_hip_roll_link.STL"/>
+    <mesh name="right_hip_yaw_link" file="right_hip_yaw_link.STL"/>
+    <mesh name="right_knee_link" file="right_knee_link.STL"/>
+    <mesh name="right_ankle_pitch_link" file="right_ankle_pitch_link.STL"/>
+    <mesh name="right_ankle_roll_link" file="right_ankle_roll_link.STL"/>
+    <mesh name="waist_yaw_link" file="waist_yaw_link_rev_1_0.STL"/>
+    <mesh name="waist_roll_link" file="waist_roll_link_rev_1_0.STL"/>
+    <mesh name="torso_link" file="torso_link_rev_1_0.STL"/>
+    <mesh name="logo_link" file="logo_link.STL"/>
+    <mesh name="head_link" file="head_link.STL"/>
+    <mesh name="left_shoulder_pitch_link" file="left_shoulder_pitch_link.STL"/>
+    <mesh name="left_shoulder_roll_link" file="left_shoulder_roll_link.STL"/>
+    <mesh name="left_shoulder_yaw_link" file="left_shoulder_yaw_link.STL"/>
+    <mesh name="left_elbow_link" file="left_elbow_link.STL"/>
+    <mesh name="left_wrist_roll_link" file="left_wrist_roll_link.STL"/>
+    <mesh name="left_wrist_pitch_link" file="left_wrist_pitch_link.STL"/>
+    <mesh name="left_wrist_yaw_link" file="left_wrist_yaw_link.STL"/>
+    <mesh name="left_rubber_hand" file="left_rubber_hand.STL"/>
+    <mesh name="right_shoulder_pitch_link" file="right_shoulder_pitch_link.STL"/>
+    <mesh name="right_shoulder_roll_link" file="right_shoulder_roll_link.STL"/>
+    <mesh name="right_shoulder_yaw_link" file="right_shoulder_yaw_link.STL"/>
+    <mesh name="right_elbow_link" file="right_elbow_link.STL"/>
+    <mesh name="right_wrist_roll_link" file="right_wrist_roll_link.STL"/>
+    <mesh name="right_wrist_pitch_link" file="right_wrist_pitch_link.STL"/>
+    <mesh name="right_wrist_yaw_link" file="right_wrist_yaw_link.STL"/>
+    <mesh name="right_rubber_hand" file="right_rubber_hand.STL"/>
+  </asset>
+
+  <worldbody>
+    <body name="pelvis" pos="0 0 0.793" childclass="g1">
+      <light pos="0 0 2" mode="trackcom" castshadow="false"/>
+      <camera name="tracking" pos="1.734 -1.135 .35" xyaxes="0.552 0.834 -0.000 -0.170 0.112 0.979" mode="trackcom"/>
+      <inertial pos="0 0 -0.07605" quat="1 0 -0.000399148 0" mass="3.813" diaginertia="0.010549 0.0093089 0.0079184"/>
+      <freejoint name="floating_base_joint"/>
+      <geom class="visual" material="black" mesh="pelvis"/>
+      <geom class="visual" mesh="pelvis_contour_link"/>
+      <geom name="pelvis_collision" class="collision" type="sphere" size="0.07" pos="0 0 -0.08"/>
+      <site name="imu_in_pelvis" size="0.01" pos="0.04525 0 -0.08339"/>
+      <body name="left_hip_pitch_link" pos="0 0.064452 -0.1027">
+        <inertial pos="0.002741 0.047791 -0.02606" quat="0.954862 0.293964 0.0302556 0.030122" mass="1.35"
+          diaginertia="0.00181517 0.00153422 0.00116212"/>
+        <joint name="left_hip_pitch_joint" axis="0 1 0" range="-2.5307 2.8798"/>
+        <geom class="visual" material="black" mesh="left_hip_pitch_link"/>
+        <body name="left_hip_roll_link" pos="0 0.052 -0.030465" quat="0.996179 0 -0.0873386 0">
+          <inertial pos="0.029812 -0.001045 -0.087934" quat="0.977808 -1.97119e-05 0.205576 -0.0403793" mass="1.52"
+            diaginertia="0.00254986 0.00241169 0.00148755"/>
+          <joint name="left_hip_roll_joint" axis="1 0 0" range="-0.5236 2.9671"/>
+          <geom class="visual" mesh="left_hip_roll_link"/>
+          <geom name="left_hip_collision" class="collision" size="0.06" fromto="0.02 0 0 0.02 0 -0.08"/>
+          <body name="left_hip_yaw_link" pos="0.025001 0 -0.12412">
+            <inertial pos="-0.057709 -0.010981 -0.15078" quat="0.600598 0.15832 0.223482 0.751181" mass="1.702"
+              diaginertia="0.00776166 0.00717575 0.00160139"/>
+            <joint name="left_hip_yaw_joint" axis="0 0 1" range="-2.7576 2.7576"/>
+            <geom class="visual" mesh="left_hip_yaw_link"/>
+            <geom name="left_thigh_collision" class="collision" size="0.055" fromto="-0.0 0 -0.03 -0.06 0 -0.17"/>
+            <body name="left_knee_link" pos="-0.078273 0.0021489 -0.17734" quat="0.996179 0 0.0873386 0">
+              <inertial pos="0.005457 0.003964 -0.12074" quat="0.923418 -0.0327699 0.0158246 0.382067" mass="1.932"
+                diaginertia="0.0113804 0.0112778 0.00146458"/>
+              <joint name="left_knee_joint" axis="0 1 0" range="-0.087267 2.8798"/>
+              <geom class="visual" mesh="left_knee_link"/>
+              <geom name="left_shin_collision" class="collision" size="0.045" fromto="0.01 0 0 0.01 0 -0.15"/>
+              <geom name="left_linkage_brace_collision" class="collision" size="0.03" fromto="0.01 0 -0.2 0.01 0 -0.28"/>
+              <body name="left_ankle_pitch_link" pos="0 -9.4445e-05 -0.30001">
+                <inertial pos="-0.007269 0 0.011137" quat="0.603053 0.369225 0.369225 0.603053" mass="0.074"
+                  diaginertia="1.89e-05 1.40805e-05 6.9195e-06"/>
+                <joint name="left_ankle_pitch_joint" axis="0 1 0" range="-0.87267 0.5236"/>
+                <geom class="visual" mesh="left_ankle_pitch_link"/>
+                <body name="left_ankle_roll_link" pos="0 0 -0.017558">
+                  <site name="left_foot" rgba="1 0 0 1" pos="0.04 0 -0.037"/>
+                  <inertial pos="0.026505 0 -0.016425" quat="-0.000481092 0.728482 -0.000618967 0.685065" mass="0.608"
+                    diaginertia="0.00167218 0.0016161 0.000217621"/>
+                  <joint name="left_ankle_roll_joint" axis="1 0 0" range="-0.2618 0.2618"/>
+                  <geom class="visual" material="black" mesh="left_ankle_roll_link"/>
+                  <geom name="left_foot1_collision" class="foot_capsule" fromto="0.1 -0.026 -0.025 0.05 -0.027 -0.025"/>
+                  <geom name="left_foot2_collision" class="foot_capsule"
+                    fromto="-0.044 -0.018 -0.025 0.123 -0.018 -0.025"/>
+                  <geom name="left_foot3_collision" class="foot_capsule" fromto="-0.052 -0.01 -0.025 0.13 -0.01 -0.025"/>
+                  <geom name="left_foot4_collision" class="foot_capsule" fromto="-0.054 0 -0.025 0.132 0 -0.025"/>
+                  <geom name="left_foot5_collision" class="foot_capsule" fromto="-0.052 0.01 -0.025 0.13 0.01 -0.025"/>
+                  <geom name="left_foot6_collision" class="foot_capsule" fromto="-0.044 0.018 -0.025 0.123 0.018 -0.025"/>
+                  <geom name="left_foot7_collision" class="foot_capsule" fromto="0.1 0.026 -0.025 0.05 0.026 -0.025"/>
+                </body>
+              </body>
+            </body>
+          </body>
+        </body>
+      </body>
+      <body name="right_hip_pitch_link" pos="0 -0.064452 -0.1027">
+        <inertial pos="0.002741 -0.047791 -0.02606" quat="0.954862 -0.293964 0.0302556 -0.030122" mass="1.35"
+          diaginertia="0.00181517 0.00153422 0.00116212"/>
+        <joint name="right_hip_pitch_joint" axis="0 1 0" range="-2.5307 2.8798"/>
+        <geom class="visual" material="black" mesh="right_hip_pitch_link"/>
+        <body name="right_hip_roll_link" pos="0 -0.052 -0.030465" quat="0.996179 0 -0.0873386 0">
+          <inertial pos="0.029812 0.001045 -0.087934" quat="0.977808 1.97119e-05 0.205576 0.0403793" mass="1.52"
+            diaginertia="0.00254986 0.00241169 0.00148755"/>
+          <joint name="right_hip_roll_joint" axis="1 0 0" range="-2.9671 0.5236"/>
+          <geom class="visual" mesh="right_hip_roll_link"/>
+          <geom name="right_hip_collision" class="collision" size="0.06" fromto="0.02 0 0 0.02 0 -0.08"/>
+          <body name="right_hip_yaw_link" pos="0.025001 0 -0.12412">
+            <inertial pos="-0.057709 0.010981 -0.15078" quat="0.751181 0.223482 0.15832 0.600598" mass="1.702"
+              diaginertia="0.00776166 0.00717575 0.00160139"/>
+            <joint name="right_hip_yaw_joint" axis="0 0 1" range="-2.7576 2.7576"/>
+            <geom class="visual" mesh="right_hip_yaw_link"/>
+            <geom name="right_thigh_collision" class="collision" size="0.055" fromto="-0.0 0 -0.03 -0.06 0 -0.17"/>
+            <body name="right_knee_link" pos="-0.078273 -0.0021489 -0.17734" quat="0.996179 0 0.0873386 0">
+              <inertial pos="0.005457 -0.003964 -0.12074" quat="0.923439 0.0345276 0.0116333 -0.382012" mass="1.932"
+                diaginertia="0.011374 0.0112843 0.00146452"/>
+              <joint name="right_knee_joint" axis="0 1 0" range="-0.087267 2.8798"/>
+              <geom class="visual" mesh="right_knee_link"/>
+              <geom name="right_shin_collision" class="collision" size="0.045" fromto="0.01 0 0 0.01 0 -0.15"/>
+              <geom name="right_linkage_brace_collision" class="collision" size="0.03" fromto="0.01 0 -0.2 0.01 0 -0.28"/>
+              <body name="right_ankle_pitch_link" pos="0 9.4445e-05 -0.30001">
+                <inertial pos="-0.007269 0 0.011137" quat="0.603053 0.369225 0.369225 0.603053" mass="0.074"
+                  diaginertia="1.89e-05 1.40805e-05 6.9195e-06"/>
+                <joint name="right_ankle_pitch_joint" axis="0 1 0" range="-0.87267 0.5236"/>
+                <geom class="visual" mesh="right_ankle_pitch_link"/>
+                <body name="right_ankle_roll_link" pos="0 0 -0.017558">
+                  <site name="right_foot" rgba="1 0 0 1" pos="0.04 0 -0.037"/>
+                  <inertial pos="0.026505 0 -0.016425" quat="0.000481092 0.728482 0.000618967 0.685065" mass="0.608"
+                    diaginertia="0.00167218 0.0016161 0.000217621"/>
+                  <joint name="right_ankle_roll_joint" axis="1 0 0" range="-0.2618 0.2618"/>
+                  <geom class="visual" material="black" mesh="right_ankle_roll_link"/>
+                  <geom name="right_foot1_collision" class="foot_capsule" fromto="0.1 -0.026 -0.025 0.05 -0.026 -0.025"/>
+                  <geom name="right_foot2_collision" class="foot_capsule"
+                    fromto="-0.044 -0.018 -0.025 0.123 -0.018 -0.025"/>
+                  <geom name="right_foot3_collision" class="foot_capsule" fromto="-0.052 -0.01 -0.025 0.13 -0.01 -0.025"/>
+                  <geom name="right_foot4_collision" class="foot_capsule" fromto="-0.054 0 -0.025 0.132 0 -0.025"/>
+                  <geom name="right_foot5_collision" class="foot_capsule" fromto="-0.052 0.01 -0.025 0.13 0.01 -0.025"/>
+                  <geom name="right_foot6_collision" class="foot_capsule"
+                    fromto="-0.044 0.018 -0.025 0.123 0.018 -0.025"/>
+                  <geom name="right_foot7_collision" class="foot_capsule" fromto="0.1 0.026 -0.025 0.05 0.026 -0.025"/>
+                </body>
+              </body>
+            </body>
+          </body>
+        </body>
+      </body>
+      <body name="waist_yaw_link">
+        <inertial pos="0.003494 0.000233 0.018034" quat="0.289697 0.591001 -0.337795 0.672821" mass="0.214"
+          diaginertia="0.000163531 0.000107714 0.000102205"/>
+        <joint name="waist_yaw_joint" axis="0 0 1" range="-2.618 2.618"/>
+        <geom class="visual" mesh="waist_yaw_link"/>
+        <body name="waist_roll_link" pos="-0.0039635 0 0.044">
+          <inertial pos="0 2.3e-05 0" quat="0.5 0.5 -0.5 0.5" mass="0.086" diaginertia="8.245e-06 7.079e-06 6.339e-06"/>
+          <joint name="waist_roll_joint" axis="1 0 0" range="-0.52 0.52"/>
+          <geom class="visual" mesh="waist_roll_link"/>
+          <body name="torso_link">
+            <inertial pos="0.00203158 0.000339683 0.184568" quat="0.999803 -6.03319e-05 0.0198256 0.00131986"
+              mass="7.818" diaginertia="0.121847 0.109825 0.0273735"/>
+            <joint name="waist_pitch_joint" axis="0 1 0" range="-0.52 0.52"/>
+            <geom class="visual" mesh="torso_link"/>
+            <geom class="visual" pos="0.0039635 0 -0.044" quat="1 0 0 0" material="black" mesh="logo_link"/>
+            <geom class="visual" pos="0.0039635 0 -0.044" material="black" mesh="head_link"/>
+            <geom name="torso_collision" class="collision" size="0.09" fromto="0.01 0 0.08 0.01 0 0.2"/>
+            <geom name="head_collision" class="collision" type="sphere" size="0.06" pos="0 0 .43"/>
+            <site name="imu_in_torso" size="0.01" pos="-0.03959 -0.00224 0.14792"/>
+            <body name="left_shoulder_pitch_link" pos="0.0039563 0.10022 0.24778"
+              quat="0.990264 0.139201 1.38722e-05 -9.86868e-05">
+              <inertial pos="0 0.035892 -0.011628" quat="0.654152 0.0130458 -0.326267 0.68225" mass="0.718"
+                diaginertia="0.000465864 0.000432842 0.000406394"/>
+              <joint name="left_shoulder_pitch_joint" axis="0 1 0" range="-3.0892 2.6704"/>
+              <geom class="visual" mesh="left_shoulder_pitch_link"/>
+              <body name="left_shoulder_roll_link" pos="0 0.038 -0.013831" quat="0.990268 -0.139172 0 0">
+                <inertial pos="-0.000227 0.00727 -0.063243" quat="0.701256 -0.0196223 -0.00710317 0.712604" mass="0.643"
+                  diaginertia="0.000691311 0.000618011 0.000388977"/>
+                <joint name="left_shoulder_roll_joint" axis="1 0 0" range="-1.5882 2.2515"/>
+                <geom class="visual" mesh="left_shoulder_roll_link"/>
+                <body name="left_shoulder_yaw_link" pos="0 0.00624 -0.1032">
+                  <inertial pos="0.010773 -0.002949 -0.072009" quat="0.716879 -0.0964829 -0.0679942 0.687134"
+                    mass="0.734" diaginertia="0.00106187 0.00103217 0.000400661"/>
+                  <joint name="left_shoulder_yaw_joint" axis="0 0 1" range="-2.618 2.618"/>
+                  <geom class="visual" mesh="left_shoulder_yaw_link"/>
+                  <geom name="left_shoulder_yaw_collision" class="collision" size="0.035" fromto="0 0 -0.08 0 0 0.05"/>
+                  <body name="left_elbow_link" pos="0.015783 0 -0.080518">
+                    <inertial pos="0.064956 0.004454 -0.010062" quat="0.541765 0.636132 0.388821 0.388129" mass="0.6"
+                      diaginertia="0.000443035 0.000421612 0.000259353"/>
+                    <joint name="left_elbow_joint" axis="0 1 0" range="-1.0472 2.0944"/>
+                    <geom class="visual" mesh="left_elbow_link"/>
+                    <geom name="left_elbow_yaw_collision" class="collision" size="0.035"
+                      fromto="-0.01 0 -0.01 0.08 0 -0.01"/>
+                    <body name="left_wrist_roll_link" pos="0.1 0.00188791 -0.01">
+                      <inertial pos="0.0171394 0.000537591 4.8864e-07" quat="0.575338 0.411667 -0.574906 0.411094"
+                        mass="0.085445" diaginertia="5.48211e-05 4.96646e-05 3.57798e-05"/>
+                      <joint name="left_wrist_roll_joint" axis="1 0 0" range="-1.97222 1.97222"/>
+                      <geom class="visual" mesh="left_wrist_roll_link"/>
+                      <body name="left_wrist_pitch_link" pos="0.038 0 0">
+                        <inertial pos="0.0229999 -0.00111685 -0.00111658" quat="0.249998 0.661363 0.293036 0.643608"
+                          mass="0.48405" diaginertia="0.000430353 0.000429873 0.000164648"/>
+                        <joint name="left_wrist_pitch_joint" axis="0 1 0" range="-1.61443 1.61443"/>
+                        <geom class="visual" mesh="left_wrist_pitch_link"/>
+                        <geom name="left_wrist_collision" class="collision" size="0.035" fromto="-0.01 0 0 0.06 0 0"/>
+                        <body name="left_wrist_yaw_link" pos="0.046 0 0">
+                          <inertial pos="0.0708244 0.000191745 0.00161742" quat="0.510571 0.526295 0.468078 0.493188"
+                            mass="0.254576" diaginertia="0.000646113 0.000559993 0.000147566"/>
+                          <joint name="left_wrist_yaw_joint" axis="0 0 1" range="-1.61443 1.61443"/>
+                          <geom class="visual" mesh="left_wrist_yaw_link"/>
+                          <geom pos="0.0415 0.003 0" quat="1 0 0 0" class="visual" mesh="left_rubber_hand"
+                            material="black"/>
+                          <site name="left_palm" pos="0.08 0 0" size="0.01"/>
+                          <geom name="left_hand_collision" class="collision" size="0.035" fromto="0.07 0 0 0.15 -0.02 0"/>
+                        </body>
+                      </body>
+                    </body>
+                  </body>
+                </body>
+              </body>
+            </body>
+            <body name="right_shoulder_pitch_link" pos="0.0039563 -0.10021 0.24778"
+              quat="0.990264 -0.139201 1.38722e-05 9.86868e-05">
+              <inertial pos="0 -0.035892 -0.011628" quat="0.68225 -0.326267 0.0130458 0.654152" mass="0.718"
+                diaginertia="0.000465864 0.000432842 0.000406394"/>
+              <joint name="right_shoulder_pitch_joint" axis="0 1 0" range="-3.0892 2.6704"/>
+              <geom class="visual" mesh="right_shoulder_pitch_link"/>
+              <body name="right_shoulder_roll_link" pos="0 -0.038 -0.013831" quat="0.990268 0.139172 0 0">
+                <inertial pos="-0.000227 -0.00727 -0.063243" quat="0.712604 -0.00710317 -0.0196223 0.701256"
+                  mass="0.643" diaginertia="0.000691311 0.000618011 0.000388977"/>
+                <joint name="right_shoulder_roll_joint" axis="1 0 0" range="-2.2515 1.5882"/>
+                <geom class="visual" mesh="right_shoulder_roll_link"/>
+                <body name="right_shoulder_yaw_link" pos="0 -0.00624 -0.1032">
+                  <inertial pos="0.010773 0.002949 -0.072009" quat="0.687134 -0.0679942 -0.0964829 0.716879"
+                    mass="0.734" diaginertia="0.00106187 0.00103217 0.000400661"/>
+                  <joint name="right_shoulder_yaw_joint" axis="0 0 1" range="-2.618 2.618"/>
+                  <geom class="visual" mesh="right_shoulder_yaw_link"/>
+                  <geom name="right_shoulder_yaw_collision" class="collision" size="0.035" fromto="0 0 -0.08 0 0 0.05"/>
+                  <body name="right_elbow_link" pos="0.015783 0 -0.080518">
+                    <inertial pos="0.064956 -0.004454 -0.010062" quat="0.388129 0.388821 0.636132 0.541765" mass="0.6"
+                      diaginertia="0.000443035 0.000421612 0.000259353"/>
+                    <joint name="right_elbow_joint" axis="0 1 0" range="-1.0472 2.0944"/>
+                    <geom class="visual" mesh="right_elbow_link"/>
+                    <geom name="right_elbow_yaw_collision" class="collision" size="0.035"
+                      fromto="-0.01 0 -0.01 0.08 0 -0.01"/>
+                    <body name="right_wrist_roll_link" pos="0.1 -0.00188791 -0.01">
+                      <inertial pos="0.0171394 -0.000537591 4.8864e-07" quat="0.411667 0.575338 -0.411094 0.574906"
+                        mass="0.085445" diaginertia="5.48211e-05 4.96646e-05 3.57798e-05"/>
+                      <joint name="right_wrist_roll_joint" axis="1 0 0" range="-1.97222 1.97222"/>
+                      <geom class="visual" mesh="right_wrist_roll_link"/>
+                      <body name="right_wrist_pitch_link" pos="0.038 0 0">
+                        <inertial pos="0.0229999 0.00111685 -0.00111658" quat="0.643608 0.293036 0.661363 0.249998"
+                          mass="0.48405" diaginertia="0.000430353 0.000429873 0.000164648"/>
+                        <joint name="right_wrist_pitch_joint" axis="0 1 0" range="-1.61443 1.61443"/>
+                        <geom class="visual" mesh="right_wrist_pitch_link"/>
+                        <geom name="right_wrist_collision" class="collision" size="0.035" fromto="-0.01 0 0 0.06 0 0"/>
+                        <body name="right_wrist_yaw_link" pos="0.046 0 0">
+                          <inertial pos="0.0708244 -0.000191745 0.00161742" quat="0.493188 0.468078 0.526295 0.510571"
+                            mass="0.254576" diaginertia="0.000646113 0.000559993 0.000147566"/>
+                          <joint name="right_wrist_yaw_joint" axis="0 0 1" range="-1.61443 1.61443"/>
+                          <geom class="visual" mesh="right_wrist_yaw_link"/>
+                          <geom pos="0.0415 -0.003 0" quat="1 0 0 0" class="visual" mesh="right_rubber_hand"
+                            material="black"/>
+                          <site name="right_palm" pos="0.08 0 0" size="0.01"/>
+                          <geom name="right_hand_collision" class="collision" size="0.035" fromto="0.07 0 0 0.15 0.02 0"/>
+                        </body>
+                      </body>
+                    </body>
+                  </body>
+                </body>
+              </body>
+            </body>
+          </body>
+        </body>
+      </body>
+    </body>
+  </worldbody>
+  <contact>
+    <exclude body1="left_elbow_link" body2="left_wrist_pitch_link"/>
+    <exclude body1="right_elbow_link" body2="right_wrist_pitch_link"/>
+    <exclude body1="pelvis" body2="right_hip_roll_link"/>
+    <exclude body1="pelvis" body2="left_hip_roll_link"/>
+  </contact>
+  <sensor>
+    <gyro name="imu_ang_vel" site="imu_in_pelvis"/>
+    <velocimeter name="imu_lin_vel" site="imu_in_pelvis"/>
+    <accelerometer name="imu_lin_acc" site="imu_in_pelvis"/>
+    <framezaxis name="imu_upvector" objtype="body" objname="world" reftype="site" refname="imu_in_pelvis"/>
+    <subtreeangmom name="root_angmom" body="pelvis"/>
+  </sensor>
+</mujoco>
diff --git a/src/mjlab/asset_zoo/robots/unitree_go1/__init__.py b/src/mjlab/asset_zoo/robots/unitree_go1/__init__.py
new file mode 100644
index 0000000..0695b41
--- /dev/null
+++ b/src/mjlab/asset_zoo/robots/unitree_go1/__init__.py
@@ -0,0 +1 @@
+"""Unitree Go1 quadruped."""
diff --git a/src/mjlab/asset_zoo/robots/unitree_go1/go1_constants.py b/src/mjlab/asset_zoo/robots/unitree_go1/go1_constants.py
new file mode 100644
index 0000000..dc8b445
--- /dev/null
+++ b/src/mjlab/asset_zoo/robots/unitree_go1/go1_constants.py
@@ -0,0 +1,173 @@
+"""Unitree Go1 constants."""
+
+from pathlib import Path
+
+import mujoco
+
+from mjlab import MJLAB_SRC_PATH
+from mjlab.actuator import BuiltinPositionActuatorCfg
+from mjlab.entity import EntityArticulationInfoCfg, EntityCfg
+from mjlab.utils.actuator import ElectricActuator, reflected_inertia
+from mjlab.utils.spec_config import CollisionCfg
+
+##
+# MJCF and assets.
+##
+
+GO1_XML: Path = (
+  MJLAB_SRC_PATH / "asset_zoo" / "robots" / "unitree_go1" / "xmls" / "go1.xml"
+)
+assert GO1_XML.exists()
+
+
+def get_spec() -> mujoco.MjSpec:
+  return mujoco.MjSpec.from_file(str(GO1_XML))
+
+
+##
+# Actuator config.
+##
+
+# Rotor inertia.
+# Ref: https://github.com/unitreerobotics/unitree_ros/blob/master/robots/go1_description/urdf/go1.urdf#L515
+# Extracted Ixx (rotation along x-axis).
+ROTOR_INERTIA = 0.000111842
+
+# Gearbox.
+HIP_GEAR_RATIO = 6
+KNEE_GEAR_RATIO = HIP_GEAR_RATIO * 1.5
+
+HIP_ACTUATOR = ElectricActuator(
+  reflected_inertia=reflected_inertia(ROTOR_INERTIA, HIP_GEAR_RATIO),
+  velocity_limit=30.1,
+  effort_limit=23.7,
+)
+KNEE_ACTUATOR = ElectricActuator(
+  reflected_inertia=reflected_inertia(ROTOR_INERTIA, KNEE_GEAR_RATIO),
+  velocity_limit=20.06,
+  effort_limit=35.55,
+)
+
+NATURAL_FREQ = 10 * 2.0 * 3.1415926535  # 10Hz
+DAMPING_RATIO = 2.0
+
+STIFFNESS_HIP = HIP_ACTUATOR.reflected_inertia * NATURAL_FREQ**2
+DAMPING_HIP = 2 * DAMPING_RATIO * HIP_ACTUATOR.reflected_inertia * NATURAL_FREQ
+
+STIFFNESS_KNEE = KNEE_ACTUATOR.reflected_inertia * NATURAL_FREQ**2
+DAMPING_KNEE = 2 * DAMPING_RATIO * KNEE_ACTUATOR.reflected_inertia * NATURAL_FREQ
+
+GO1_HIP_ACTUATOR_CFG = BuiltinPositionActuatorCfg(
+  target_names_expr=(".*_hip_joint", ".*_thigh_joint"),
+  stiffness=STIFFNESS_HIP,
+  damping=DAMPING_HIP,
+  effort_limit=HIP_ACTUATOR.effort_limit,
+  armature=HIP_ACTUATOR.reflected_inertia,
+)
+GO1_KNEE_ACTUATOR_CFG = BuiltinPositionActuatorCfg(
+  target_names_expr=(".*_calf_joint",),
+  stiffness=STIFFNESS_KNEE,
+  damping=DAMPING_KNEE,
+  effort_limit=KNEE_ACTUATOR.effort_limit,
+  armature=KNEE_ACTUATOR.reflected_inertia,
+)
+
+##
+# Keyframes.
+##
+
+
+INIT_STATE = EntityCfg.InitialStateCfg(
+  pos=(0.0, 0.0, 0.278),
+  joint_pos={
+    ".*thigh_joint": 0.9,
+    ".*calf_joint": -1.8,
+    ".*R_hip_joint": 0.1,
+    ".*L_hip_joint": -0.1,
+  },
+  joint_vel={".*": 0.0},
+)
+
+##
+# Collision config.
+##
+
+_foot_regex = "^[FR][LR]_foot_collision$"
+
+# This disables all collisions except the feet.
+# Furthermore, feet self collisions are disabled.
+FEET_ONLY_COLLISION = CollisionCfg(
+  geom_names_expr=(_foot_regex,),
+  contype=0,
+  conaffinity=1,
+  condim=3,
+  priority=1,
+  friction=(0.6,),
+  solimp=(0.9, 0.95, 0.023),
+)
+
+# This enables all collisions.
+# Foot collisions are given custom condim, friction.
+# The go1 XML numbers its secondary collision capsules (FR_thigh_collision1,
+# RL_calf_collision2, ...), so the pattern allows a trailing index. This keeps
+# the match set identical whether patterns are matched by prefix or in full.
+_collision_regex = r".*_collision\d*"
+
+FULL_COLLISION = CollisionCfg(
+  geom_names_expr=(_collision_regex,),
+  contype=1,
+  conaffinity=1,
+  # Harden all collision geoms.
+  solref=(0.01, 1),
+  # Configure feet colliders. Other colliders are frictionless (condim=1).
+  condim={_foot_regex: 6, _collision_regex: 1},
+  priority={_foot_regex: 1, ".*": 0},
+  friction={_foot_regex: (1, 5e-3, 5e-4)},
+)
+
+##
+# Final config.
+##
+
+GO1_ARTICULATION = EntityArticulationInfoCfg(
+  actuators=(
+    GO1_HIP_ACTUATOR_CFG,
+    GO1_KNEE_ACTUATOR_CFG,
+  ),
+  soft_joint_pos_limit_factor=0.9,
+)
+
+
+def get_go1_robot_cfg() -> EntityCfg:
+  """Get a fresh Go1 robot configuration instance.
+
+  Returns a new EntityCfg instance each time to avoid mutation issues when
+  the config is shared across multiple places.
+  """
+  return EntityCfg(
+    init_state=INIT_STATE,
+    collisions=(FULL_COLLISION,),
+    spec_fn=get_spec,
+    articulation=GO1_ARTICULATION,
+  )
+
+
+GO1_ACTION_SCALE: dict[str, float] = {}
+for a in GO1_ARTICULATION.actuators:
+  assert isinstance(a, BuiltinPositionActuatorCfg)
+  e = a.effort_limit
+  s = a.stiffness
+  names = a.target_names_expr
+  assert e is not None
+  for n in names:
+    GO1_ACTION_SCALE[n] = 0.25 * e / s
+
+
+if __name__ == "__main__":
+  import mujoco.viewer as viewer
+
+  from mjlab.entity.entity import Entity
+
+  robot = Entity(get_go1_robot_cfg())
+
+  viewer.launch(robot.spec.compile())
diff --git a/src/mjlab/asset_zoo/robots/unitree_go1/xmls/assets/calf.stl b/src/mjlab/asset_zoo/robots/unitree_go1/xmls/assets/calf.stl
new file mode 100644
index 0000000..3e8ac94
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_go1/xmls/assets/calf.stl differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_go1/xmls/assets/hip.stl b/src/mjlab/asset_zoo/robots/unitree_go1/xmls/assets/hip.stl
new file mode 100644
index 0000000..ae590bf
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_go1/xmls/assets/hip.stl differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_go1/xmls/assets/thigh.stl b/src/mjlab/asset_zoo/robots/unitree_go1/xmls/assets/thigh.stl
new file mode 100644
index 0000000..353801b
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_go1/xmls/assets/thigh.stl differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_go1/xmls/assets/thigh_mirror.stl b/src/mjlab/asset_zoo/robots/unitree_go1/xmls/assets/thigh_mirror.stl
new file mode 100644
index 0000000..11ef770
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_go1/xmls/assets/thigh_mirror.stl differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_go1/xmls/assets/trunk.stl b/src/mjlab/asset_zoo/robots/unitree_go1/xmls/assets/trunk.stl
new file mode 100644
index 0000000..2659eb1
Binary files /dev/null and b/src/mjlab/asset_zoo/robots/unitree_go1/xmls/assets/trunk.stl differ
diff --git a/src/mjlab/asset_zoo/robots/unitree_go1/xmls/go1.xml b/src/mjlab/asset_zoo/robots/unitree_go1/xmls/go1.xml
new file mode 100644
index 0000000..cc6cacb
--- /dev/null
+++ b/src/mjlab/asset_zoo/robots/unitree_go1/xmls/go1.xml
@@ -0,0 +1,171 @@
+<mujoco model="go1">
+  <compiler angle="radian" meshdir="assets" autolimits="true"/>
+
+  <default>
+    <default class="go1">
+      <default class="visual">
+        <geom type="mesh" contype="0" conaffinity="0" group="2" material="dark"/>
+      </default>
+      <default class="collision">
+        <geom group="3" type="capsule" contype="1" conaffinity="1"/>
+        <default class="thigh1">
+          <geom size="0.015" fromto="-0.02 0 0 -0.02 0 -0.16"/>
+        </default>
+        <default class="thigh2">
+          <geom size="0.015" fromto="0 0 0 -0.02 0 -0.1"/>
+        </default>
+        <default class="thigh3">
+          <geom size="0.015" fromto="-0.02 0 -0.16 0 0 -0.2"/>
+        </default>
+        <default class="calf1">
+          <geom size="0.01" fromto="0 0 0 0.02 0 -0.13"/>
+        </default>
+        <default class="calf2">
+          <geom size="0.01" fromto="0.02 0 -0.13 0 0 -0.2"/>
+        </default>
+        <default class="foot">
+          <geom type="sphere" size="0.023" pos="0 0 -0.213"/>
+        </default>
+      </default>
+    </default>
+  </default>
+
+  <asset>
+    <material name="dark" rgba="0.2 0.2 0.2 1"/>
+
+    <mesh class="go1" file="trunk.stl"/>
+    <mesh class="go1" file="hip.stl"/>
+    <mesh class="go1" file="thigh_mirror.stl"/>
+    <mesh class="go1" file="calf.stl"/>
+    <mesh class="go1" file="thigh.stl"/>
+  </asset>
+
+  <worldbody>
+    <body name="trunk" pos="0 0 0.445" childclass="go1">
+      <light pos="0 0 2" mode="trackcom"/>
+      <camera name="tracking" pos="0.846 -1.3 0.316" xyaxes="0.866 0.500 0.000 -0.171 0.296 0.940" mode="trackcom"/>
+      <camera name="top" pos="-1 0 1" xyaxes="0 -1 0 0.7 0 0.7" mode="trackcom"/>
+      <camera name="side" pos="0 -1 .3" xyaxes="1 0 0 0 1 2" mode="trackcom"/>
+      <camera name="back" pos="-1 0 .3" xyaxes="0 -1 0 1 0 2" mode="trackcom"/>
+      <site name="head" pos="0.3 0 0" rgba="1 0 0 1" size="0.02" group="5"/>
+      <inertial pos="0.0223 0.002 -0.0005" quat="-0.00342088 0.705204 0.000106698 0.708996" mass="5.204"
+        diaginertia="0.0716565 0.0630105 0.0168101"/>
+      <freejoint name="floating_base_joint"/>
+      <geom class="visual" mesh="trunk"/>
+      <geom name="trunk_collision" class="collision" type="box" size="0.13 0.09 0.05" pos="0 0 0"/>
+      <geom name="head_collision" class="collision" type="sphere" size="0.06" pos="0.24 0 0"/>
+      <site name="imu" pos="-0.01592 -0.06659 -0.00617" group="5"/>
+      <body name="FR_hip" pos="0.1881 -0.04675 0">
+        <inertial pos="-0.0049166 0.00762615 -8.865e-05" quat="0.507341 0.514169 0.495027 0.482891" mass="0.68"
+          diaginertia="0.000734064 0.000468438 0.000398719"/>
+        <joint name="FR_hip_joint" axis="1 0 0" range="-0.863 0.863"/>
+        <geom class="visual" mesh="hip" quat="1 0 0 0"/>
+        <geom name="FR_hip_collision" class="collision" type="capsule" fromto="0 -0.02 0 0 -0.04 0" size="0.05"/>
+        <body name="FR_thigh" pos="0 -0.08 0">
+          <inertial pos="-0.00304722 0.019315 -0.0305004" quat="0.65243 -0.0272313 0.0775126 0.753383" mass="1.009"
+            diaginertia="0.00478717 0.00460903 0.000709268"/>
+          <joint name="FR_thigh_joint" axis="0 1 0" range="-0.686 4.501"/>
+          <geom class="visual" mesh="thigh_mirror"/>
+          <geom name="FR_thigh_collision1" class="thigh1"/>
+          <geom name="FR_thigh_collision2" class="thigh2"/>
+          <geom name="FR_thigh_collision3" class="thigh3"/>
+          <body name="FR_calf" pos="0 0 -0.213">
+            <inertial pos="0.00429862 0.000976676 -0.146197" quat="0.691246 0.00357467 0.00511118 0.722592"
+              mass="0.195862" diaginertia="0.00149767 0.00148468 3.58427e-05"/>
+            <joint name="FR_calf_joint" axis="0 1 0" range="-2.818 -0.888"/>
+            <geom class="visual" mesh="calf"/>
+            <geom name="FR_calf_collision1" class="calf1"/>
+            <geom name="FR_calf_collision2" class="calf2"/>
+            <geom name="FR_foot_collision" class="foot"/>
+            <site name="FR" pos="0 0 -0.213" type="sphere" size="0.023" group="5"/>
+          </body>
+        </body>
+      </body>
+      <body name="FL_hip" pos="0.1881 0.04675 0">
+        <inertial pos="-0.0049166 -0.00762615 -8.865e-05" quat="0.482891 0.495027 0.514169 0.507341" mass="0.68"
+          diaginertia="0.000734064 0.000468438 0.000398719"/>
+        <joint name="FL_hip_joint" axis="1 0 0" range="-0.863 0.863"/>
+        <geom class="visual" mesh="hip"/>
+        <geom name="FL_hip_collision" class="collision" type="capsule" fromto="0 0.02 0 0 0.04 0" size="0.05"/>
+        <body name="FL_thigh" pos="0 0.08 0">
+          <inertial pos="-0.00304722 -0.019315 -0.0305004" quat="0.753383 0.0775126 -0.0272313 0.65243" mass="1.009"
+            diaginertia="0.00478717 0.00460903 0.000709268"/>
+          <joint name="FL_thigh_joint" axis="0 1 0" range="-0.686 4.501"/>
+          <geom class="visual" mesh="thigh"/>
+          <geom name="FL_thigh_collision1" class="thigh1"/>
+          <geom name="FL_thigh_collision2" class="thigh2"/>
+          <geom name="FL_thigh_collision3" class="thigh3"/>
+          <body name="FL_calf" pos="0 0 -0.213">
+            <inertial pos="0.00429862 0.000976676 -0.146197" quat="0.691246 0.00357467 0.00511118 0.722592"
+              mass="0.195862" diaginertia="0.00149767 0.00148468 3.58427e-05"/>
+            <joint name="FL_calf_joint" axis="0 1 0" range="-2.818 -0.888"/>
+            <geom class="visual" mesh="calf"/>
+            <geom name="FL_calf_collision1" class="calf1"/>
+            <geom name="FL_calf_collision2" class="calf2"/>
+            <geom name="FL_foot_collision" class="foot"/>
+            <site name="FL" pos="0 0 -0.213" type="sphere" size="0.023" group="5"/>
+          </body>
+        </body>
+      </body>
+      <body name="RR_hip" pos="-0.1881 -0.04675 0">
+        <inertial pos="0.0049166 0.00762615 -8.865e-05" quat="0.495027 0.482891 0.507341 0.514169" mass="0.68"
+          diaginertia="0.000734064 0.000468438 0.000398719"/>
+        <joint name="RR_hip_joint" axis="1 0 0" range="-0.863 0.863"/>
+        <geom class="visual" quat="0 0 0 -1" mesh="hip"/>
+        <geom name="RR_hip_collision" class="collision" type="capsule" fromto="0 -0.02 0 0 -0.04 0" size="0.05"/>
+        <body name="RR_thigh" pos="0 -0.08 0">
+          <inertial pos="-0.00304722 0.019315 -0.0305004" quat="0.65243 -0.0272313 0.0775126 0.753383" mass="1.009"
+            diaginertia="0.00478717 0.00460903 0.000709268"/>
+          <joint name="RR_thigh_joint" axis="0 1 0" range="-0.686 4.501"/>
+          <geom class="visual" mesh="thigh_mirror"/>
+          <geom name="RR_thigh_collision1" class="thigh1"/>
+          <geom name="RR_thigh_collision2" class="thigh2"/>
+          <geom name="RR_thigh_collision3" class="thigh3"/>
+          <body name="RR_calf" pos="0 0 -0.213">
+            <inertial pos="0.00429862 0.000976676 -0.146197" quat="0.691246 0.00357467 0.00511118 0.722592"
+              mass="0.195862" diaginertia="0.00149767 0.00148468 3.58427e-05"/>
+            <joint name="RR_calf_joint" axis="0 1 0" range="-2.818 -0.888"/>
+            <geom class="visual" mesh="calf"/>
+            <geom name="RR_calf_collision1" class="calf1"/>
+            <geom name="RR_calf_collision2" class="calf2"/>
+            <geom name="RR_foot_collision" class="foot"/>
+            <site name="RR" pos="0 0 -0.213" type="sphere" size="0.023" group="5"/>
+          </body>
+        </body>
+      </body>
+      <body name="RL_hip" pos="-0.1881 0.04675 0">
+        <inertial pos="0.0049166 -0.00762615 -8.865e-05" quat="0.514169 0.507341 0.482891 0.495027" mass="0.68"
+          diaginertia="0.000734064 0.000468438 0.000398719"/>
+        <joint name="RL_hip_joint" axis="1 0 0" range="-0.863 0.863"/>
+        <geom class="visual" quat="0 0 1 0" mesh="hip"/>
+        <geom name="RL_hip_collision" class="collision" type="capsule" fromto="0 0.02 0 0 0.04 0" size="0.05"/>
+        <body name="RL_thigh" pos="0 0.08 0">
+          <inertial pos="-0.00304722 -0.019315 -0.0305004" quat="0.753383 0.0775126 -0.0272313 0.65243" mass="1.009"
+            diaginertia="0.00478717 0.00460903 0.000709268"/>
+          <joint name="RL_thigh_joint" axis="0 1 0" range="-0.686 4.501"/>
+          <geom class="visual" mesh="thigh"/>
+          <geom name="RL_thigh_collision1" class="thigh1"/>
+          <geom name="RL_thigh_collision2" class="thigh2"/>
+          <geom name="RL_thigh_collision3" class="thigh3"/>
+          <body name="RL_calf" pos="0 0 -0.213">
+            <inertial pos="0.00429862 0.000976676 -0.146197" quat="0.691246 0.00357467 0.00511118 0.722592"
+              mass="0.195862" diaginertia="0.00149767 0.00148468 3.58427e-05"/>
+            <joint name="RL_calf_joint" axis="0 1 0" range="-2.818 -0.888"/>
+            <geom class="visual" mesh="calf"/>
+            <geom name="RL_calf_collision1" class="calf1"/>
+            <geom name="RL_calf_collision2" class="calf2"/>
+            <geom name="RL_foot_collision" class="foot"/>
+            <site name="RL" pos="0 0 -0.213" type="sphere" size="0.023" group="5"/>
+          </body>
+        </body>
+      </body>
+    </body>
+  </worldbody>
+  <sensor>
+    <gyro name="imu_ang_vel" site="imu"/>
+    <velocimeter name="imu_lin_vel" site="imu"/>
+    <accelerometer name="imu_lin_acc" site="imu"/>
+    <framezaxis name="imu_upvector" objtype="body" objname="world" reftype="site" refname="imu"/>
+    <subtreeangmom name="root_angmom" body="trunk"/>
+  </sensor>
+</mujoco>
diff --git a/src/mjlab/entity/__init__.py b/src/mjlab/entity/__init__.py
new file mode 100644
index 0000000..f6cffff
--- /dev/null
+++ b/src/mjlab/entity/__init__.py
@@ -0,0 +1,7 @@
+from mjlab.entity.data import EntityData as EntityData
+from mjlab.entity.entity import Entity as Entity
+from mjlab.entity.entity import EntityArticulationInfoCfg as EntityArticulationInfoCfg
+from mjlab.entity.entity import EntityCfg as EntityCfg
+from mjlab.entity.entity import EntityIndexing as EntityIndexing
+from mjlab.entity.variants import VariantEntityCfg as VariantEntityCfg
+from mjlab.entity.variants import VariantMetadata as VariantMetadata
diff --git a/src/mjlab/entity/data.py b/src/mjlab/entity/data.py
new file mode 100644
index 0000000..0d66775
--- /dev/null
+++ b/src/mjlab/entity/data.py
@@ -0,0 +1,631 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Sequence
+
+import mujoco_warp as mjwarp
+import torch
+
+from mjlab.utils.lab_api.math import (
+  quat_apply,
+  quat_apply_inverse,
+  quat_from_matrix,
+  quat_mul,
+)
+
+if TYPE_CHECKING:
+  from mjlab.entity.entity import EntityIndexing
+
+
+def compute_velocity_from_cvel(
+  pos: torch.Tensor,
+  subtree_com: torch.Tensor,
+  cvel: torch.Tensor,
+) -> torch.Tensor:
+  """Convert cvel quantities to world-frame velocities."""
+  lin_vel_c = cvel[..., 3:6]
+  ang_vel_c = cvel[..., 0:3]
+  offset = subtree_com - pos
+  lin_vel_w = lin_vel_c - torch.cross(ang_vel_c, offset, dim=-1)
+  ang_vel_w = ang_vel_c
+  return torch.cat([lin_vel_w, ang_vel_w], dim=-1)
+
+
+@dataclass
+class EntityData:
+  """Data container for an entity.
+
+  Note: Write methods (write_*) modify state directly. Read properties (e.g.,
+  root_link_pose_w) require sim.forward() to be current. If you write then read,
+  call sim.forward() in between. Event order matters when mixing reads and writes.
+  All inputs/outputs use world frame.
+  """
+
+  indexing: EntityIndexing
+  data: mjwarp.Data
+  model: mjwarp.Model
+  device: str
+
+  default_root_state: torch.Tensor
+  default_joint_pos: torch.Tensor
+  default_joint_vel: torch.Tensor
+
+  default_joint_pos_limits: torch.Tensor
+  joint_pos_limits: torch.Tensor
+  soft_joint_pos_limits: torch.Tensor
+
+  gravity_vec_w: torch.Tensor
+  forward_vec_b: torch.Tensor
+
+  is_fixed_base: bool
+  is_articulated: bool
+  is_actuated: bool
+
+  joint_pos_target: torch.Tensor
+  joint_vel_target: torch.Tensor
+  joint_effort_target: torch.Tensor
+
+  tendon_len_target: torch.Tensor
+  tendon_vel_target: torch.Tensor
+  tendon_effort_target: torch.Tensor
+
+  site_effort_target: torch.Tensor
+
+  encoder_bias: torch.Tensor
+
+  # State dimensions.
+  POS_DIM = 3
+  QUAT_DIM = 4
+  LIN_VEL_DIM = 3
+  ANG_VEL_DIM = 3
+  ROOT_POSE_DIM = POS_DIM + QUAT_DIM  # 7
+  ROOT_VEL_DIM = LIN_VEL_DIM + ANG_VEL_DIM  # 6
+  ROOT_STATE_DIM = ROOT_POSE_DIM + ROOT_VEL_DIM  # 13
+
+  def write_root_state(
+    self, root_state: torch.Tensor, env_ids: torch.Tensor | slice | None = None
+  ) -> None:
+    if self.is_fixed_base:
+      raise ValueError("Cannot write root state for fixed-base entity.")
+    assert root_state.shape[-1] == self.ROOT_STATE_DIM
+
+    self.write_root_pose(root_state[:, : self.ROOT_POSE_DIM], env_ids)
+    self.write_root_velocity(root_state[:, self.ROOT_POSE_DIM :], env_ids)
+
+  def write_root_pose(
+    self, pose: torch.Tensor, env_ids: torch.Tensor | slice | None = None
+  ) -> None:
+    if self.is_fixed_base:
+      raise ValueError("Cannot write root pose for fixed-base entity.")
+    assert pose.shape[-1] == self.ROOT_POSE_DIM
+
+    env_ids = self._resolve_env_ids(env_ids)
+    self.data.qpos[env_ids, self.indexing.free_joint_q_adr] = pose
+
+  def write_root_velocity(
+    self, velocity: torch.Tensor, env_ids: torch.Tensor | slice | None = None
+  ) -> None:
+    if self.is_fixed_base:
+      raise ValueError("Cannot write root velocity for fixed-base entity.")
+    assert velocity.shape[-1] == self.ROOT_VEL_DIM
+
+    env_ids = self._resolve_env_ids(env_ids)
+    quat_w = self.data.qpos[env_ids, self.indexing.free_joint_q_adr[3:7]]
+    ang_vel_b = quat_apply_inverse(quat_w, velocity[:, 3:])
+    velocity_qvel = torch.cat([velocity[:, :3], ang_vel_b], dim=-1)
+    self.data.qvel[env_ids, self.indexing.free_joint_v_adr] = velocity_qvel
+
+  def write_root_velocity_b(
+    self, velocity_b: torch.Tensor, env_ids: torch.Tensor | slice | None = None
+  ) -> None:
+    """Write the root link velocity given in the root link's body frame.
+
+    The orientation is read from qpos, so this is safe to call during a reset
+    before forward() has refreshed derived kinematics.
+    """
+    if self.is_fixed_base:
+      raise ValueError("Cannot write root velocity for fixed-base entity.")
+    assert velocity_b.shape[-1] == self.ROOT_VEL_DIM
+
+    env_ids = self._resolve_env_ids(env_ids)
+    quat_w = self.data.qpos[env_ids, self.indexing.free_joint_q_adr[3:7]]
+    lin_vel_w = quat_apply(quat_w, velocity_b[:, :3])
+    # Free joint qvel holds world-frame linear and body-frame angular velocity.
+    velocity_qvel = torch.cat([lin_vel_w, velocity_b[:, 3:]], dim=-1)
+    self.data.qvel[env_ids, self.indexing.free_joint_v_adr] = velocity_qvel
+
+  def write_root_com_velocity(
+    self, velocity: torch.Tensor, env_ids: torch.Tensor | slice | None = None
+  ) -> None:
+    if self.is_fixed_base:
+      raise ValueError("Cannot write root COM velocity for fixed-base entity.")
+    assert velocity.shape[-1] == self.ROOT_VEL_DIM
+
+    env_ids = env_ids if env_ids is not None else slice(None)
+    com_offset_b = self.model.body_ipos[:, self.indexing.root_body_id]
+    quat_w = self.data.qpos[:, self.indexing.free_joint_q_adr[3:7]][env_ids]
+    com_offset_w = quat_apply(quat_w, com_offset_b[env_ids])
+    lin_vel_com = velocity[:, :3]
+    ang_vel_w = velocity[:, 3:]
+    lin_vel_link = lin_vel_com - torch.cross(ang_vel_w, com_offset_w, dim=-1)
+    link_velocity = torch.cat([lin_vel_link, ang_vel_w], dim=-1)
+    self.write_root_velocity(link_velocity, env_ids)
+
+  def write_joint_state(
+    self,
+    position: torch.Tensor,
+    velocity: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    if not self.is_articulated:
+      raise ValueError("Cannot write joint state for non-articulated entity.")
+
+    self.write_joint_position(position, joint_ids, env_ids)
+    self.write_joint_velocity(velocity, joint_ids, env_ids)
+
+  def write_joint_position(
+    self,
+    position: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    if not self.is_articulated:
+      raise ValueError("Cannot write joint position for non-articulated entity.")
+
+    env_ids = self._resolve_env_ids(env_ids)
+    joint_ids = joint_ids if joint_ids is not None else slice(None)
+    q_slice = self.indexing.joint_q_adr[joint_ids]
+    self.data.qpos[env_ids, q_slice] = position
+
+  def write_joint_velocity(
+    self,
+    velocity: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    if not self.is_articulated:
+      raise ValueError("Cannot write joint velocity for non-articulated entity.")
+
+    env_ids = self._resolve_env_ids(env_ids)
+    joint_ids = joint_ids if joint_ids is not None else slice(None)
+    v_slice = self.indexing.joint_v_adr[joint_ids]
+    self.data.qvel[env_ids, v_slice] = velocity
+
+  def write_external_wrench(
+    self,
+    force: torch.Tensor | None,
+    torque: torch.Tensor | None,
+    body_ids: Sequence[int] | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    env_ids = self._resolve_env_ids(env_ids)
+    local_body_ids = body_ids if body_ids is not None else slice(None)
+    global_body_ids = self.indexing.body_ids[local_body_ids]
+    if force is not None:
+      self.data.xfrc_applied[env_ids, global_body_ids, 0:3] = force
+    if torque is not None:
+      self.data.xfrc_applied[env_ids, global_body_ids, 3:6] = torque
+
+  def write_ctrl(
+    self,
+    ctrl: torch.Tensor,
+    ctrl_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    if not self.is_actuated:
+      raise ValueError("Cannot write control for non-actuated entity.")
+
+    env_ids = self._resolve_env_ids(env_ids)
+    local_ctrl_ids = ctrl_ids if ctrl_ids is not None else slice(None)
+    global_ctrl_ids = self.indexing.ctrl_ids[local_ctrl_ids]
+    self.data.ctrl[env_ids, global_ctrl_ids] = ctrl
+
+  def write_mocap_pose(
+    self, pose: torch.Tensor, env_ids: torch.Tensor | slice | None = None
+  ) -> None:
+    if self.indexing.mocap_id is None:
+      raise ValueError("Cannot write mocap pose for non-mocap entity.")
+    assert pose.shape[-1] == self.ROOT_POSE_DIM
+
+    env_ids = self._resolve_env_ids(env_ids)
+    self.data.mocap_pos[env_ids, self.indexing.mocap_id] = pose[:, 0:3].unsqueeze(1)
+    self.data.mocap_quat[env_ids, self.indexing.mocap_id] = pose[:, 3:7].unsqueeze(1)
+
+  def clear_state(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    if self.is_actuated:
+      env_ids = self._resolve_env_ids(env_ids)
+      self.joint_pos_target[env_ids] = 0.0
+      self.joint_vel_target[env_ids] = 0.0
+      self.joint_effort_target[env_ids] = 0.0
+      self.tendon_len_target[env_ids] = 0.0
+      self.tendon_vel_target[env_ids] = 0.0
+      self.tendon_effort_target[env_ids] = 0.0
+      self.site_effort_target[env_ids] = 0.0
+
+  def _resolve_env_ids(
+    self, env_ids: torch.Tensor | slice | None
+  ) -> torch.Tensor | slice:
+    """Convert env_ids to consistent indexing format."""
+    if env_ids is None:
+      return slice(None)
+    if isinstance(env_ids, torch.Tensor):
+      return env_ids[:, None]
+    return env_ids
+
+  def _joint_dof_field(self, field_name: str) -> torch.Tensor:
+    """Return a generalized-force field sliced to this entity's joint DoFs."""
+    field = getattr(self.data, field_name)
+    return field[:, self.indexing.joint_v_adr]
+
+  # Root properties
+
+  @property
+  def root_link_pose_w(self) -> torch.Tensor:
+    """Root link pose in world frame. Shape (num_envs, 7)."""
+    pos_w = self.data.xpos[:, self.indexing.root_body_id]  # (num_envs, 3)
+    quat_w = self.data.xquat[:, self.indexing.root_body_id]  # (num_envs, 4)
+    return torch.cat([pos_w, quat_w], dim=-1)  # (num_envs, 7)
+
+  @property
+  def root_link_vel_w(self) -> torch.Tensor:
+    """Root link velocity in world frame. Shape (num_envs, 6)."""
+    # NOTE: Equivalently, can read this from qvel[:6] but the angular part
+    # will be in body frame and needs to be rotated to world frame.
+    # Note also that an extra forward() call might be required to make
+    # both values equal.
+    pos = self.data.xpos[:, self.indexing.root_body_id]  # (num_envs, 3)
+    subtree_com = self.data.subtree_com[:, self.indexing.root_body_id]
+    cvel = self.data.cvel[:, self.indexing.root_body_id]  # (num_envs, 6)
+    return compute_velocity_from_cvel(pos, subtree_com, cvel)  # (num_envs, 6)
+
+  @property
+  def root_com_pose_w(self) -> torch.Tensor:
+    """Root center-of-mass pose in world frame. Shape (num_envs, 7)."""
+    pos_w = self.data.xipos[:, self.indexing.root_body_id]
+    quat = self.data.xquat[:, self.indexing.root_body_id]
+    body_iquat = self.model.body_iquat[:, self.indexing.root_body_id]
+    assert body_iquat is not None
+    quat_w = quat_mul(quat, body_iquat.squeeze(1))
+    return torch.cat([pos_w, quat_w], dim=-1)
+
+  @property
+  def root_com_vel_w(self) -> torch.Tensor:
+    """Root center-of-mass velocity in world frame. Shape (num_envs, 6)."""
+    # NOTE: Equivalent sensor is framelinvel/frameangvel with objtype="body".
+    pos = self.data.xipos[:, self.indexing.root_body_id]  # (num_envs, 3)
+    subtree_com = self.data.subtree_com[:, self.indexing.root_body_id]
+    cvel = self.data.cvel[:, self.indexing.root_body_id]  # (num_envs, 6)
+    return compute_velocity_from_cvel(pos, subtree_com, cvel)  # (num_envs, 6)
+
+  # Body properties
+
+  @property
+  def body_link_pose_w(self) -> torch.Tensor:
+    """Body link pose in world frame. Shape (num_envs, num_bodies, 7)."""
+    pos_w = self.data.xpos[:, self.indexing.body_ids]
+    quat_w = self.data.xquat[:, self.indexing.body_ids]
+    return torch.cat([pos_w, quat_w], dim=-1)
+
+  @property
+  def body_link_vel_w(self) -> torch.Tensor:
+    """Body link velocity in world frame. Shape (num_envs, num_bodies, 6)."""
+    # NOTE: Equivalent sensor is framelinvel/frameangvel with objtype="xbody".
+    pos = self.data.xpos[:, self.indexing.body_ids]  # (num_envs, num_bodies, 3)
+    subtree_com = self.data.subtree_com[:, self.indexing.root_body_id]
+    cvel = self.data.cvel[:, self.indexing.body_ids]
+    return compute_velocity_from_cvel(pos, subtree_com.unsqueeze(1), cvel)
+
+  @property
+  def body_com_pose_w(self) -> torch.Tensor:
+    """Body center-of-mass pose in world frame. Shape (num_envs, num_bodies, 7)."""
+    pos_w = self.data.xipos[:, self.indexing.body_ids]
+    quat = self.data.xquat[:, self.indexing.body_ids]
+    body_iquat = self.model.body_iquat[:, self.indexing.body_ids]
+    quat_w = quat_mul(quat, body_iquat)
+    return torch.cat([pos_w, quat_w], dim=-1)
+
+  @property
+  def body_com_vel_w(self) -> torch.Tensor:
+    """Body center-of-mass velocity in world frame. Shape (num_envs, num_bodies, 6)."""
+    # NOTE: Equivalent sensor is framelinvel/frameangvel with objtype="body".
+    pos = self.data.xipos[:, self.indexing.body_ids]
+    subtree_com = self.data.subtree_com[:, self.indexing.root_body_id]
+    cvel = self.data.cvel[:, self.indexing.body_ids]
+    return compute_velocity_from_cvel(pos, subtree_com.unsqueeze(1), cvel)
+
+  @property
+  def body_external_wrench(self) -> torch.Tensor:
+    """Body external wrench in world frame. Shape (num_envs, num_bodies, 6)."""
+    return self.data.xfrc_applied[:, self.indexing.body_ids]
+
+  # Geom properties
+
+  @property
+  def geom_pose_w(self) -> torch.Tensor:
+    """Geom pose in world frame. Shape (num_envs, num_geoms, 7)."""
+    pos_w = self.data.geom_xpos[:, self.indexing.geom_ids]
+    xmat = self.data.geom_xmat[:, self.indexing.geom_ids]
+    quat_w = quat_from_matrix(xmat)
+    return torch.cat([pos_w, quat_w], dim=-1)
+
+  @property
+  def geom_vel_w(self) -> torch.Tensor:
+    """Geom velocity in world frame. Shape (num_envs, num_geoms, 6)."""
+    pos = self.data.geom_xpos[:, self.indexing.geom_ids]
+    body_ids = self.model.geom_bodyid[self.indexing.geom_ids]  # (num_geoms,)
+    subtree_com = self.data.subtree_com[:, self.indexing.root_body_id]
+    cvel = self.data.cvel[:, body_ids]
+    return compute_velocity_from_cvel(pos, subtree_com.unsqueeze(1), cvel)
+
+  # Site properties
+
+  @property
+  def site_pose_w(self) -> torch.Tensor:
+    """Site pose in world frame. Shape (num_envs, num_sites, 7)."""
+    pos_w = self.data.site_xpos[:, self.indexing.site_ids]
+    mat_w = self.data.site_xmat[:, self.indexing.site_ids]
+    quat_w = quat_from_matrix(mat_w)
+    return torch.cat([pos_w, quat_w], dim=-1)
+
+  @property
+  def site_vel_w(self) -> torch.Tensor:
+    """Site velocity in world frame. Shape (num_envs, num_sites, 6)."""
+    pos = self.data.site_xpos[:, self.indexing.site_ids]
+    body_ids = self.model.site_bodyid[self.indexing.site_ids]  # (num_sites,)
+    subtree_com = self.data.subtree_com[:, self.indexing.root_body_id]
+    cvel = self.data.cvel[:, body_ids]
+    return compute_velocity_from_cvel(pos, subtree_com.unsqueeze(1), cvel)
+
+  # Joint properties
+
+  @property
+  def joint_pos(self) -> torch.Tensor:
+    """Joint positions. Shape (num_envs, num_joints)."""
+    return self.data.qpos[:, self.indexing.joint_q_adr]
+
+  @property
+  def joint_pos_biased(self) -> torch.Tensor:
+    """Joint positions with encoder bias applied. Shape (num_envs, num_joints)."""
+    return self.joint_pos + self.encoder_bias
+
+  @property
+  def joint_vel(self) -> torch.Tensor:
+    """Joint velocities. Shape (num_envs, nv)."""
+    return self.data.qvel[:, self.indexing.joint_v_adr]
+
+  @property
+  def joint_acc(self) -> torch.Tensor:
+    """Joint accelerations. Shape (num_envs, nv)."""
+    return self.data.qacc[:, self.indexing.joint_v_adr]
+
+  # Tendon properties
+
+  @property
+  def tendon_len(self) -> torch.Tensor:
+    """Tendon lengths. Shape (num_envs, num_tendons)."""
+    return self.data.ten_length[:, self.indexing.tendon_ids]
+
+  @property
+  def tendon_vel(self) -> torch.Tensor:
+    """Tendon velocities. Shape (num_envs, num_tendons)."""
+    return self.data.ten_velocity[:, self.indexing.tendon_ids]
+
+  # Generalized forces
+
+  @property
+  def joint_torques(self) -> torch.Tensor:
+    """Joint torques. Shape (num_envs, nv)."""
+    raise NotImplementedError(
+      "Joint torques are ambiguous. Use 'qfrc_actuator' for actuator forces "
+      "in joint space, or 'qfrc_external' for body wrench contributions."
+    )
+
+  @property
+  def actuator_force(self) -> torch.Tensor:
+    """Scalar actuator output in actuation space. Shape (num_envs, nu).
+
+    This is not the same as joint-space generalized force. Use ``qfrc_actuator`` for
+    the actuator contribution projected into DoF space.
+    """
+    return self.data.actuator_force[:, self.indexing.ctrl_ids]
+
+  @property
+  def qfrc_actuator(self) -> torch.Tensor:
+    """Forces produced by all actuators, mapped into joint space.
+
+    For motors this is the commanded torque times the gear ratio. For position and
+    velocity actuators this is the force computed by the internal PD law. When
+    ``actuatorgravcomp`` is enabled on a joint, the gravity compensation force is
+    included here.
+    """
+    return self._joint_dof_field("qfrc_actuator")
+
+  @property
+  def qfrc_external(self) -> torch.Tensor:
+    """Forces on joints due to Cartesian wrenches applied to bodies.
+
+    When a force or torque is applied to a body via ``xfrc_applied``, this property
+    gives the equivalent joint forces (the Jacobian transpose mapping).
+    """
+    # MuJoCo folds J^T * xfrc_applied into qfrc_smooth without storing it.
+    # Recover via the qfrc_smooth identity:
+    #   qfrc_smooth = qfrc_actuator + qfrc_passive - qfrc_bias
+    #                 + qfrc_applied + J^T * xfrc_applied
+    f = self._joint_dof_field
+    return (
+      f("qfrc_smooth")
+      - f("qfrc_actuator")
+      - f("qfrc_applied")
+      - f("qfrc_passive")
+      + f("qfrc_bias")
+    )
+
+  # Pose and velocity component accessors.
+
+  @property
+  def root_link_pos_w(self) -> torch.Tensor:
+    """Root link position in world frame. Shape (num_envs, 3)."""
+    return self.root_link_pose_w[:, 0:3]
+
+  @property
+  def root_link_quat_w(self) -> torch.Tensor:
+    """Root link quaternion in world frame. Shape (num_envs, 4)."""
+    return self.root_link_pose_w[:, 3:7]
+
+  @property
+  def root_link_lin_vel_w(self) -> torch.Tensor:
+    """Root link linear velocity in world frame. Shape (num_envs, 3)."""
+    return self.root_link_vel_w[:, 0:3]
+
+  @property
+  def root_link_ang_vel_w(self) -> torch.Tensor:
+    """Root link angular velocity in world frame. Shape (num_envs, 3)."""
+    return self.data.cvel[:, self.indexing.root_body_id, 0:3]
+
+  @property
+  def root_com_pos_w(self) -> torch.Tensor:
+    """Root COM position in world frame. Shape (num_envs, 3)."""
+    return self.root_com_pose_w[:, 0:3]
+
+  @property
+  def root_com_quat_w(self) -> torch.Tensor:
+    """Root COM quaternion in world frame. Shape (num_envs, 4)."""
+    return self.root_com_pose_w[:, 3:7]
+
+  @property
+  def root_com_lin_vel_w(self) -> torch.Tensor:
+    """Root COM linear velocity in world frame. Shape (num_envs, 3)."""
+    return self.root_com_vel_w[:, 0:3]
+
+  @property
+  def root_com_ang_vel_w(self) -> torch.Tensor:
+    """Root COM angular velocity in world frame. Shape (num_envs, 3)."""
+    # Angular velocity is the same for link and COM frames.
+    return self.data.cvel[:, self.indexing.root_body_id, 0:3]
+
+  @property
+  def body_link_pos_w(self) -> torch.Tensor:
+    """Body link positions in world frame. Shape (num_envs, num_bodies, 3)."""
+    return self.body_link_pose_w[..., 0:3]
+
+  @property
+  def body_link_quat_w(self) -> torch.Tensor:
+    """Body link quaternions in world frame. Shape (num_envs, num_bodies, 4)."""
+    return self.body_link_pose_w[..., 3:7]
+
+  @property
+  def body_link_lin_vel_w(self) -> torch.Tensor:
+    """Body link linear velocities in world frame. Shape (num_envs, num_bodies, 3)."""
+    return self.body_link_vel_w[..., 0:3]
+
+  @property
+  def body_link_ang_vel_w(self) -> torch.Tensor:
+    """Body link angular velocities in world frame. Shape (num_envs, num_bodies, 3)."""
+    return self.data.cvel[:, self.indexing.body_ids, 0:3]
+
+  @property
+  def body_com_pos_w(self) -> torch.Tensor:
+    """Body COM positions in world frame. Shape (num_envs, num_bodies, 3)."""
+    return self.body_com_pose_w[..., 0:3]
+
+  @property
+  def body_com_quat_w(self) -> torch.Tensor:
+    """Body COM quaternions in world frame. Shape (num_envs, num_bodies, 4)."""
+    return self.body_com_pose_w[..., 3:7]
+
+  @property
+  def body_com_lin_vel_w(self) -> torch.Tensor:
+    """Body COM linear velocities in world frame. Shape (num_envs, num_bodies, 3)."""
+    return self.body_com_vel_w[..., 0:3]
+
+  @property
+  def body_com_ang_vel_w(self) -> torch.Tensor:
+    """Body COM angular velocities in world frame. Shape (num_envs, num_bodies, 3)."""
+    # Angular velocity is the same for link and COM frames.
+    return self.data.cvel[:, self.indexing.body_ids, 0:3]
+
+  @property
+  def body_external_force(self) -> torch.Tensor:
+    """Body external forces in world frame. Shape (num_envs, num_bodies, 3)."""
+    return self.body_external_wrench[..., 0:3]
+
+  @property
+  def body_external_torque(self) -> torch.Tensor:
+    """Body external torques in world frame. Shape (num_envs, num_bodies, 3)."""
+    return self.body_external_wrench[..., 3:6]
+
+  @property
+  def geom_pos_w(self) -> torch.Tensor:
+    """Geom positions in world frame. Shape (num_envs, num_geoms, 3)."""
+    return self.geom_pose_w[..., 0:3]
+
+  @property
+  def geom_quat_w(self) -> torch.Tensor:
+    """Geom quaternions in world frame. Shape (num_envs, num_geoms, 4)."""
+    return self.geom_pose_w[..., 3:7]
+
+  @property
+  def geom_lin_vel_w(self) -> torch.Tensor:
+    """Geom linear velocities in world frame. Shape (num_envs, num_geoms, 3)."""
+    return self.geom_vel_w[..., 0:3]
+
+  @property
+  def geom_ang_vel_w(self) -> torch.Tensor:
+    """Geom angular velocities in world frame. Shape (num_envs, num_geoms, 3)."""
+    body_ids = self.model.geom_bodyid[self.indexing.geom_ids]
+    return self.data.cvel[:, body_ids, 0:3]
+
+  @property
+  def site_pos_w(self) -> torch.Tensor:
+    """Site positions in world frame. Shape (num_envs, num_sites, 3)."""
+    return self.site_pose_w[..., 0:3]
+
+  @property
+  def site_quat_w(self) -> torch.Tensor:
+    """Site quaternions in world frame. Shape (num_envs, num_sites, 4)."""
+    return self.site_pose_w[..., 3:7]
+
+  @property
+  def site_lin_vel_w(self) -> torch.Tensor:
+    """Site linear velocities in world frame. Shape (num_envs, num_sites, 3)."""
+    return self.site_vel_w[..., 0:3]
+
+  @property
+  def site_ang_vel_w(self) -> torch.Tensor:
+    """Site angular velocities in world frame. Shape (num_envs, num_sites, 3)."""
+    body_ids = self.model.site_bodyid[self.indexing.site_ids]
+    return self.data.cvel[:, body_ids, 0:3]
+
+  # Derived properties.
+
+  @property
+  def projected_gravity_b(self) -> torch.Tensor:
+    """Gravity vector projected into body frame. Shape (num_envs, 3)."""
+    return quat_apply_inverse(self.root_link_quat_w, self.gravity_vec_w)
+
+  @property
+  def heading_w(self) -> torch.Tensor:
+    """Heading angle in world frame. Shape (num_envs,)."""
+    forward_w = quat_apply(self.root_link_quat_w, self.forward_vec_b)
+    return torch.atan2(forward_w[:, 1], forward_w[:, 0])
+
+  @property
+  def root_link_lin_vel_b(self) -> torch.Tensor:
+    """Root link linear velocity in body frame. Shape (num_envs, 3)."""
+    return quat_apply_inverse(self.root_link_quat_w, self.root_link_lin_vel_w)
+
+  @property
+  def root_link_ang_vel_b(self) -> torch.Tensor:
+    """Root link angular velocity in body frame. Shape (num_envs, 3)."""
+    return quat_apply_inverse(self.root_link_quat_w, self.root_link_ang_vel_w)
+
+  @property
+  def root_com_lin_vel_b(self) -> torch.Tensor:
+    """Root COM linear velocity in body frame. Shape (num_envs, 3)."""
+    return quat_apply_inverse(self.root_link_quat_w, self.root_com_lin_vel_w)
+
+  @property
+  def root_com_ang_vel_b(self) -> torch.Tensor:
+    """Root COM angular velocity in body frame. Shape (num_envs, 3)."""
+    return quat_apply_inverse(self.root_link_quat_w, self.root_com_ang_vel_w)
diff --git a/src/mjlab/entity/entity.py b/src/mjlab/entity/entity.py
new file mode 100644
index 0000000..77685ac
--- /dev/null
+++ b/src/mjlab/entity/entity.py
@@ -0,0 +1,1341 @@
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Callable, Sequence
+
+import mujoco
+import mujoco_warp as mjwarp
+import numpy as np
+import torch
+
+from mjlab import actuator
+from mjlab.actuator import BuiltinActuatorGroup, FusedActuatorGroup
+from mjlab.actuator.actuator import TransmissionType
+from mjlab.actuator.xml_actuator import XmlActuator
+from mjlab.entity.data import EntityData
+from mjlab.utils import spec_config as spec_cfg
+from mjlab.utils.lab_api.string import resolve_matching_names
+from mjlab.utils.mujoco import dof_width, qpos_width
+from mjlab.utils.spec import auto_wrap_fixed_base_mocap
+from mjlab.utils.string import resolve_expr
+from mjlab.utils.xml import fix_spec_xml, strip_buffer_textures
+
+if TYPE_CHECKING:
+  from mjlab.entity.variants import VariantMetadata
+
+
+@dataclass(frozen=False)
+class EntityIndexing:
+  """Maps entity elements to global indices and addresses in the simulation."""
+
+  # Elements.
+  bodies: tuple[mujoco.MjsBody, ...]
+  joints: tuple[mujoco.MjsJoint, ...]
+  geoms: tuple[mujoco.MjsGeom, ...]
+  sites: tuple[mujoco.MjsSite, ...]
+  tendons: tuple[mujoco.MjsTendon, ...]
+  cameras: tuple[mujoco.MjsCamera, ...]
+  lights: tuple[mujoco.MjsLight, ...]
+  materials: tuple[mujoco.MjsMaterial, ...]
+  textures: tuple[mujoco.MjsTexture, ...]
+  pairs: tuple[mujoco.MjsPair, ...]
+  actuators: tuple[mujoco.MjsActuator, ...] | None
+
+  # Indices.
+  body_ids: torch.Tensor
+  geom_ids: torch.Tensor
+  site_ids: torch.Tensor
+  tendon_ids: torch.Tensor
+  cam_ids: torch.Tensor
+  light_ids: torch.Tensor
+  mat_ids: torch.Tensor
+  tex_ids: torch.Tensor
+  pair_ids: torch.Tensor
+  ctrl_ids: torch.Tensor
+  joint_ids: torch.Tensor
+  mocap_id: int | None
+
+  # Addresses.
+  joint_q_adr: torch.Tensor
+  joint_v_adr: torch.Tensor
+  free_joint_q_adr: torch.Tensor
+  free_joint_v_adr: torch.Tensor
+
+  @property
+  def root_body_id(self) -> int:
+    return self.bodies[0].id
+
+
+def _outer_index(
+  env_ids: torch.Tensor | slice, ids: torch.Tensor | slice
+) -> tuple[torch.Tensor | slice, torch.Tensor | slice]:
+  """Make [env_ids, ids] select the outer product when both are tensors.
+
+  Plain [tensor, tensor] indexing pairs the ids elementwise, which silently
+  writes a diagonal whenever the shapes happen to broadcast.
+  """
+  if isinstance(env_ids, torch.Tensor) and isinstance(ids, torch.Tensor):
+    return env_ids[:, None], ids
+  return env_ids, ids
+
+
+@dataclass
+class EntityCfg:
+  @dataclass
+  class InitialStateCfg:
+    # Root position and orientation.
+    pos: tuple[float, float, float] = (0.0, 0.0, 0.0)
+    rot: tuple[float, float, float, float] = (1.0, 0.0, 0.0, 0.0)
+    # Root linear and angular velocity (only for floating base entities).
+    lin_vel: tuple[float, float, float] = (0.0, 0.0, 0.0)
+    ang_vel: tuple[float, float, float] = (0.0, 0.0, 0.0)
+    # Articulation (only for articulated entities).
+    # Set to None to use the model's existing keyframe (errors if none exists).
+    joint_pos: dict[str, float] | None = field(default_factory=lambda: {".*": 0.0})
+    joint_vel: dict[str, float] = field(default_factory=lambda: {".*": 0.0})
+
+  init_state: InitialStateCfg = field(default_factory=InitialStateCfg)
+  spec_fn: Callable[[], mujoco.MjSpec] = field(
+    default_factory=lambda: lambda: mujoco.MjSpec()
+  )
+  articulation: EntityArticulationInfoCfg | None = None
+  sort_actuators: bool = False
+  """When True, reorder actuators so that ``model.ctrl`` follows joint/tendon/site
+  definition order rather than the order actuators appear in the config. XML actuators
+  are excluded from sorting and always retain their declaration order.
+  """
+
+  # Editors.
+  lights: tuple[spec_cfg.LightCfg, ...] = field(default_factory=tuple)
+  cameras: tuple[spec_cfg.CameraCfg, ...] = field(default_factory=tuple)
+  textures: tuple[spec_cfg.TextureCfg, ...] = field(default_factory=tuple)
+  materials: tuple[spec_cfg.MaterialCfg, ...] = field(default_factory=tuple)
+  meshes: tuple[spec_cfg.MeshCfg, ...] = field(default_factory=tuple)
+  geoms: tuple[spec_cfg.GeomCfg, ...] = field(default_factory=tuple)
+  collisions: tuple[spec_cfg.CollisionCfg, ...] = field(default_factory=tuple)
+
+  def build(self) -> Entity:
+    """Build entity instance from this config.
+
+    Override in subclasses to return custom Entity types.
+    """
+    return Entity(self)
+
+
+@dataclass
+class EntityArticulationInfoCfg:
+  actuators: tuple[actuator.ActuatorCfg, ...] = field(default_factory=tuple)
+  soft_joint_pos_limit_factor: float = 1.0
+
+
+class Entity:
+  """An entity represents a physical object in the simulation.
+
+  Entity Type Matrix
+  ==================
+  MuJoCo entities can be categorized along two dimensions:
+
+  1. Base Type:
+    - Fixed Base: Entity is welded to the world (no freejoint)
+    - Floating Base: Entity has 6 DOF movement (has freejoint)
+
+  2. Articulation:
+    - Non-articulated: No joints other than freejoint
+    - Articulated: Has joints in kinematic tree (may or may not be actuated)
+
+  Fixed non-articulated entities can optionally be mocap bodies, whereby their
+  position and orientation can be set directly each timestep rather than being
+  determined by physics. This property can be useful for creating props with
+  adjustable position and orientation.
+
+  Supported Combinations:
+  ----------------------
+  | Type                      | Example             | is_fixed_base | is_articulated | is_actuated |
+  |---------------------------|---------------------|---------------|----------------|-------------|
+  | Fixed Non-articulated     | Table, wall         | True          | False          | False       |
+  | Fixed Articulated         | Robot arm, door     | True          | True           | True/False  |
+  | Floating Non-articulated  | Box, ball, mug      | False         | False          | False       |
+  | Floating Articulated      | Humanoid, quadruped | False         | True           | True/False  |
+  """
+
+  def __init__(self, cfg: EntityCfg) -> None:
+    self.cfg = cfg
+    self._actuators: list[actuator.Actuator] = []
+    self._variant_metadata: VariantMetadata | None = None
+    self._build_spec()
+    self._identify_joints()
+    self._apply_spec_editors()
+    self._add_actuators()
+    self._add_initial_state_keyframe()
+
+  def _build_spec(self) -> None:
+    from mjlab.entity.variants import VariantEntityCfg, build_merged_variant_spec
+
+    if isinstance(self.cfg, VariantEntityCfg):
+      self._spec, self._variant_metadata = build_merged_variant_spec(self.cfg)
+    else:
+      self._spec = auto_wrap_fixed_base_mocap(self.cfg.spec_fn)()
+
+  @property
+  def variant_metadata(self) -> VariantMetadata | None:
+    return self._variant_metadata
+
+  def _identify_joints(self) -> None:
+    self._all_joints = self._spec.joints
+    self._free_joint = None
+    self._non_free_joints = tuple(self._all_joints)
+
+    free_joints = [j for j in self._all_joints if j.type == mujoco.mjtJoint.mjJNT_FREE]
+    if len(free_joints) > 1:
+      raise ValueError(
+        f"Entity spec has {len(free_joints)} freejoints. An Entity models a "
+        "single rigid- or articulated-body system with at most one freejoint, "
+        "which serves as its root. Model each detached floating body as its own "
+        "entry in SceneCfg.entities instead."
+      )
+
+    if self._all_joints and self._all_joints[0].type == mujoco.mjtJoint.mjJNT_FREE:
+      self._free_joint = self._all_joints[0]
+      if not self._free_joint.name:
+        self._free_joint.name = "floating_base_joint"
+      self._non_free_joints = tuple(self._all_joints[1:])
+
+  def _apply_spec_editors(self) -> None:
+    spec_cfg.warn_overlapping_geom_edits(
+      self.cfg.geoms, self.cfg.collisions, self._spec
+    )
+    for cfg_list in [
+      self.cfg.lights,
+      self.cfg.cameras,
+      self.cfg.textures,
+      self.cfg.materials,
+      self.cfg.meshes,
+      self.cfg.geoms,
+      self.cfg.collisions,
+    ]:
+      for cfg in cfg_list:
+        cfg.edit_spec(self._spec)
+
+  def _add_actuators(self) -> None:
+    if self.cfg.articulation is None:
+      return
+
+    # Collect actuator instances and their targets.
+    pending: list[tuple[actuator.ActuatorCfg, actuator.Actuator, list[str]]] = []
+    for actuator_cfg in self.cfg.articulation.actuators:
+      # Find targets based on transmission type. resolve_matching_names raises
+      # ValueError when no regex matches; we catch that to produce a better error with
+      # namespace hints below.
+      target_ids: list[int] = []
+      target_names: list[str] = []
+      target_spec_names: list[str] = []
+      try:
+        if actuator_cfg.transmission_type == TransmissionType.JOINT:
+          target_ids, target_names = self.find_joints(actuator_cfg.target_names_expr)
+          target_spec_names = [self._non_free_joints[i].name for i in target_ids]
+        elif actuator_cfg.transmission_type == TransmissionType.TENDON:
+          target_ids, target_names = self.find_tendons(actuator_cfg.target_names_expr)
+          target_spec_names = [self._spec.tendons[i].name for i in target_ids]
+        elif actuator_cfg.transmission_type == TransmissionType.SITE:
+          target_ids, target_names = self.find_sites(actuator_cfg.target_names_expr)
+          target_spec_names = [self.spec.sites[i].name for i in target_ids]
+        else:
+          raise TypeError(
+            f"Invalid transmission_type: {actuator_cfg.transmission_type}. "
+            f"Must be TransmissionType.JOINT, TransmissionType.TENDON, "
+            f"or TransmissionType.SITE."
+          )
+      except ValueError:
+        pass  # target_names stays empty, fall through to hint logic
+
+      # Check other namespaces for matches. If we found nothing, this produces a
+      # helpful error. If we did find targets, it warns about unactuated matches in
+      # other namespaces.
+      current = actuator_cfg.transmission_type
+      other_matches: dict[TransmissionType, tuple[str, list[str]]] = {}
+      other_namespaces = {
+        TransmissionType.JOINT: ("joint", self.joint_names),
+        TransmissionType.TENDON: ("tendon", self.tendon_names),
+        TransmissionType.SITE: ("site", self.site_names),
+      }
+      for tt, (label, names) in other_namespaces.items():
+        if tt == current or not names:
+          continue
+        try:
+          _, matched = resolve_matching_names(actuator_cfg.target_names_expr, names)
+          other_matches[tt] = (label, matched)
+        except ValueError:
+          pass
+
+      if len(target_names) == 0:
+        msg = (
+          f"No {current.value}s matched expressions: {actuator_cfg.target_names_expr}"
+        )
+        if other_matches:
+          hints = [
+            f"{label}s ({', '.join(matched)})"
+            for label, matched in other_matches.values()
+          ]
+          msg += (
+            f". Matches were found in: {'; '.join(hints)}. "
+            f"Check that transmission_type is correct."
+          )
+        raise ValueError(msg)
+
+      for tt, (label, matched) in other_matches.items():
+        warnings.warn(
+          f"Actuator config matched {len(target_names)} {current.value}(s) "
+          f"but the same expressions also match {len(matched)} {label}(s): "
+          f"{', '.join(matched)}. Add a separate config with "
+          f"transmission_type=TransmissionType.{tt.name} if those should "
+          f"be actuated too.",
+          stacklevel=2,
+        )
+
+      actuator_instance = actuator_cfg.build(self, target_ids, target_names)
+      self._actuators.append(actuator_instance)
+      pending.append((actuator_cfg, actuator_instance, target_spec_names))
+
+    if not self.cfg.sort_actuators:
+      for _, inst, names in pending:
+        inst.edit_spec(self._spec, names)
+      return
+
+    # Sort actuators so ctrl order matches joint/tendon/site definition order.
+    # XmlActuators are added first (they wrap pre-existing XML actuators),
+    # then remaining actuators sorted by transmission type and target order.
+    order_maps = {
+      TransmissionType.JOINT: {name: i for i, name in enumerate(self.joint_names)},
+      TransmissionType.TENDON: {name: i for i, name in enumerate(self.tendon_names)},
+      TransmissionType.SITE: {name: i for i, name in enumerate(self.site_names)},
+    }
+    # Group by transmission type (ordering is conventional, not physics-motivated).
+    # Within each group, actuators are sorted by their target's definition order in the
+    # spec.
+    type_priority = {
+      TransmissionType.JOINT: 0,
+      TransmissionType.TENDON: 1,
+      TransmissionType.SITE: 2,
+    }
+
+    # XmlActuators go first in declaration order (they reference actuators already
+    # present in the spec).
+    for _, inst, names in pending:
+      if isinstance(inst, XmlActuator):
+        inst.edit_spec(self._spec, names)
+
+    # Flatten remaining actuators to (instance, single_target) pairs and sort.
+    flat: list[tuple[actuator.ActuatorCfg, actuator.Actuator, str]] = []
+    for cfg, inst, names in pending:
+      if not isinstance(inst, XmlActuator):
+        for name in names:
+          flat.append((cfg, inst, name))
+
+    flat.sort(
+      key=lambda item: (
+        type_priority[item[0].transmission_type],
+        order_maps[item[0].transmission_type].get(item[2], float("inf")),
+      )
+    )
+    for _, inst, name in flat:
+      inst.edit_spec(self._spec, [name])
+
+  def _add_initial_state_keyframe(self) -> None:
+    # If joint_pos is None, use existing keyframe from the model.
+    if self.cfg.init_state.joint_pos is None:
+      if not self._spec.keys:
+        raise ValueError(
+          "joint_pos=None requires the model to have a keyframe, but none exists."
+        )
+      # Keep the existing keyframe, just rename it.
+      self._spec.keys[0].name = "init_state"
+      if self.is_fixed_base:
+        self.root_body.pos[:] = self.cfg.init_state.pos
+        self.root_body.quat[:] = self.cfg.init_state.rot
+      return
+
+    qpos_components = []
+
+    if self._free_joint is not None:
+      qpos_components.extend([self.cfg.init_state.pos, self.cfg.init_state.rot])
+
+    joint_pos = None
+    if self._non_free_joints:
+      joint_pos = resolve_expr(self.cfg.init_state.joint_pos, self.joint_names, 0.0)
+      qpos_components.append(joint_pos)
+
+    key_qpos = np.hstack(qpos_components) if qpos_components else np.array([])
+    key = self._spec.add_key(name="init_state", qpos=key_qpos.tolist())
+
+    if self.is_actuated and joint_pos is not None:
+      name_to_pos = {name: joint_pos[i] for i, name in enumerate(self.joint_names)}
+      ctrl = []
+      for act in self._spec.actuators:
+        joint_name = act.target
+        ctrl.append(name_to_pos.get(joint_name, 0.0))
+      key.ctrl = np.array(ctrl)
+
+    if self.is_fixed_base:
+      self.root_body.pos[:] = self.cfg.init_state.pos
+      self.root_body.quat[:] = self.cfg.init_state.rot
+
+  # Attributes.
+
+  @property
+  def is_fixed_base(self) -> bool:
+    """Entity is welded to the world."""
+    return self._free_joint is None
+
+  @property
+  def is_articulated(self) -> bool:
+    """Entity is articulated (has fixed or actuated joints)."""
+    return len(self._non_free_joints) > 0
+
+  @property
+  def is_actuated(self) -> bool:
+    """Entity has actuated joints."""
+    return len(self._actuators) > 0
+
+  @property
+  def has_tendon_actuators(self) -> bool:
+    """Entity has actuators using tendon transmission."""
+    if self.cfg.articulation is None:
+      return False
+    return any(
+      act.transmission_type == TransmissionType.TENDON
+      for act in self.cfg.articulation.actuators
+    )
+
+  @property
+  def has_site_actuators(self) -> bool:
+    """Entity has actuators using site transmission."""
+    if self.cfg.articulation is None:
+      return False
+    return any(
+      act.transmission_type == TransmissionType.SITE
+      for act in self.cfg.articulation.actuators
+    )
+
+  @property
+  def is_mocap(self) -> bool:
+    """Entity root body is a mocap body (only for fixed-base entities)."""
+    return bool(self.root_body.mocap) if self.is_fixed_base else False
+
+  @property
+  def spec(self) -> mujoco.MjSpec:
+    return self._spec
+
+  @property
+  def data(self) -> EntityData:
+    return self._data
+
+  @property
+  def actuators(self) -> list[actuator.Actuator]:
+    return self._actuators
+
+  # Names.
+
+  @property
+  def body_names(self) -> tuple[str, ...]:
+    return tuple(b.name.split("/")[-1] for b in self.spec.bodies[1:])
+
+  @property
+  def all_joint_names(self) -> tuple[str, ...]:
+    return tuple(j.name.split("/")[-1] for j in self._all_joints)
+
+  @property
+  def joint_names(self) -> tuple[str, ...]:
+    return tuple(j.name.split("/")[-1] for j in self._non_free_joints)
+
+  @property
+  def geom_names(self) -> tuple[str, ...]:
+    return tuple(g.name.split("/")[-1] for g in self.spec.geoms)
+
+  @property
+  def site_names(self) -> tuple[str, ...]:
+    return tuple(s.name.split("/")[-1] for s in self.spec.sites)
+
+  @property
+  def tendon_names(self) -> tuple[str, ...]:
+    return tuple(t.name.split("/")[-1] for t in self._spec.tendons)
+
+  @property
+  def camera_names(self) -> tuple[str, ...]:
+    return tuple(c.name.split("/")[-1] for c in self.spec.cameras)
+
+  @property
+  def light_names(self) -> tuple[str, ...]:
+    return tuple(lt.name.split("/")[-1] for lt in self.spec.lights)
+
+  @property
+  def material_names(self) -> tuple[str, ...]:
+    return tuple(m.name.split("/")[-1] for m in self.spec.materials)
+
+  @property
+  def texture_names(self) -> tuple[str, ...]:
+    return tuple(t.name.split("/")[-1] for t in self.spec.textures)
+
+  @property
+  def pair_names(self) -> tuple[str, ...]:
+    return tuple(p.name.split("/")[-1] for p in self.spec.pairs)
+
+  @property
+  def actuator_names(self) -> tuple[str, ...]:
+    return tuple(a.name.split("/")[-1] for a in self.spec.actuators)
+
+  # Counts.
+
+  @property
+  def num_bodies(self) -> int:
+    return len(self.body_names)
+
+  @property
+  def num_joints(self) -> int:
+    return len(self.joint_names)
+
+  @property
+  def num_geoms(self) -> int:
+    return len(self.geom_names)
+
+  @property
+  def num_sites(self) -> int:
+    return len(self.site_names)
+
+  @property
+  def num_tendons(self) -> int:
+    return len(self.tendon_names)
+
+  @property
+  def num_cameras(self) -> int:
+    return len(self.camera_names)
+
+  @property
+  def num_lights(self) -> int:
+    return len(self.light_names)
+
+  @property
+  def num_materials(self) -> int:
+    return len(self.material_names)
+
+  @property
+  def num_textures(self) -> int:
+    return len(self.texture_names)
+
+  @property
+  def num_pairs(self) -> int:
+    return len(self.pair_names)
+
+  @property
+  def num_actuators(self) -> int:
+    return len(self.actuator_names)
+
+  @property
+  def root_body(self) -> mujoco.MjsBody:
+    return self.spec.bodies[1]
+
+  # Find methods.
+
+  def find_bodies(
+    self, name_keys: str | Sequence[str], preserve_order: bool = False
+  ) -> tuple[list[int], list[str]]:
+    return resolve_matching_names(name_keys, self.body_names, preserve_order)
+
+  def find_joints(
+    self,
+    name_keys: str | Sequence[str],
+    joint_subset: Sequence[str] | None = None,
+    preserve_order: bool = False,
+  ) -> tuple[list[int], list[str]]:
+    if joint_subset is None:
+      joint_subset = self.joint_names
+    return resolve_matching_names(name_keys, joint_subset, preserve_order)
+
+  def find_joints_by_actuator_names(
+    self,
+    actuator_name_keys: str | Sequence[str],
+  ) -> tuple[list[int], list[str]]:
+    # Collect all actuated joint names.
+    actuated_joint_names_set = set()
+    for act in self._actuators:
+      actuated_joint_names_set.update(act.target_names)
+
+    # Filter self.joint_names to only actuated joints, preserving natural order.
+    actuated_in_natural_order = [
+      name for name in self.joint_names if name in actuated_joint_names_set
+    ]
+
+    # Find joints matching the pattern within actuated joints.
+    _, matched_joint_names = self.find_joints(
+      actuator_name_keys, joint_subset=actuated_in_natural_order, preserve_order=False
+    )
+
+    # Map joint names back to entity-local indices (indices into self.joint_names).
+    name_to_entity_idx = {name: i for i, name in enumerate(self.joint_names)}
+    joint_ids = [name_to_entity_idx[name] for name in matched_joint_names]
+    return joint_ids, matched_joint_names
+
+  def find_geoms(
+    self,
+    name_keys: str | Sequence[str],
+    geom_subset: Sequence[str] | None = None,
+    preserve_order: bool = False,
+  ) -> tuple[list[int], list[str]]:
+    if geom_subset is None:
+      geom_subset = self.geom_names
+    return resolve_matching_names(name_keys, geom_subset, preserve_order)
+
+  def find_sites(
+    self,
+    name_keys: str | Sequence[str],
+    site_subset: Sequence[str] | None = None,
+    preserve_order: bool = False,
+  ) -> tuple[list[int], list[str]]:
+    if site_subset is None:
+      site_subset = self.site_names
+    return resolve_matching_names(name_keys, site_subset, preserve_order)
+
+  def find_tendons(
+    self,
+    name_keys: str | Sequence[str],
+    tendon_subset: Sequence[str] | None = None,
+    preserve_order: bool = False,
+  ) -> tuple[list[int], list[str]]:
+    if tendon_subset is None:
+      tendon_subset = self.tendon_names
+    return resolve_matching_names(name_keys, tendon_subset, preserve_order)
+
+  def find_cameras(
+    self,
+    name_keys: str | Sequence[str],
+    camera_subset: Sequence[str] | None = None,
+    preserve_order: bool = False,
+  ) -> tuple[list[int], list[str]]:
+    if camera_subset is None:
+      camera_subset = self.camera_names
+    return resolve_matching_names(name_keys, camera_subset, preserve_order)
+
+  def find_lights(
+    self,
+    name_keys: str | Sequence[str],
+    light_subset: Sequence[str] | None = None,
+    preserve_order: bool = False,
+  ) -> tuple[list[int], list[str]]:
+    if light_subset is None:
+      light_subset = self.light_names
+    return resolve_matching_names(name_keys, light_subset, preserve_order)
+
+  def find_materials(
+    self,
+    name_keys: str | Sequence[str],
+    material_subset: Sequence[str] | None = None,
+    preserve_order: bool = False,
+  ) -> tuple[list[int], list[str]]:
+    if material_subset is None:
+      material_subset = self.material_names
+    return resolve_matching_names(name_keys, material_subset, preserve_order)
+
+  def find_textures(
+    self,
+    name_keys: str | Sequence[str],
+    texture_subset: Sequence[str] | None = None,
+    preserve_order: bool = False,
+  ) -> tuple[list[int], list[str]]:
+    if texture_subset is None:
+      texture_subset = self.texture_names
+    return resolve_matching_names(name_keys, texture_subset, preserve_order)
+
+  def find_pairs(
+    self,
+    name_keys: str | Sequence[str],
+    pair_subset: Sequence[str] | None = None,
+    preserve_order: bool = False,
+  ) -> tuple[list[int], list[str]]:
+    if pair_subset is None:
+      pair_subset = self.pair_names
+    return resolve_matching_names(name_keys, pair_subset, preserve_order)
+
+  def find_actuators(
+    self,
+    name_keys: str | Sequence[str],
+    actuator_subset: Sequence[str] | None = None,
+    preserve_order: bool = False,
+  ) -> tuple[list[int], list[str]]:
+    if actuator_subset is None:
+      actuator_subset = self.actuator_names
+    return resolve_matching_names(name_keys, actuator_subset, preserve_order)
+
+  def compile(self) -> mujoco.MjModel:
+    """Compile the underlying MjSpec into an MjModel."""
+    return self.spec.compile()
+
+  def write_xml(self, xml_path: Path) -> None:
+    """Write the MjSpec to disk.
+
+    Operates on a copy of the spec to avoid mutating the original.
+    """
+    tmp = self.spec.copy()
+    strip_buffer_textures(tmp)
+    xml_path.write_text(fix_spec_xml(tmp.to_xml()))
+
+  def to_zip(self, path: Path) -> None:
+    """Write the MjSpec to a zip file."""
+    with path.open("wb") as f:
+      mujoco.MjSpec.to_zip(self.spec, f)
+
+  def initialize(
+    self,
+    mj_model: mujoco.MjModel,
+    model: mjwarp.Model,
+    data: mjwarp.Data,
+    device: str,
+  ) -> None:
+    """Prepare the entity for simulation after the spec has been compiled.
+
+    Computes global index mappings, initializes actuators, and allocates all nworld
+    state and target tensors in ``EntityData``. Called once by the scene during
+    environment construction.
+    """
+    indexing = self._compute_indexing(mj_model, device)
+    self.indexing = indexing
+    nworld = data.nworld
+
+    for act in self._actuators:
+      act.initialize(mj_model, model, data, device)
+
+    # Vectorize built-in actuators, then fuse ideal PD actuators; we'll loop
+    # through whatever custom actuators remain.
+    builtin_group, custom_actuators = BuiltinActuatorGroup.process(self._actuators)
+    builtin_group.initialize(nworld, device)
+    self._builtin_group = builtin_group
+    fused_actuator_group, custom_actuators = FusedActuatorGroup.process(
+      custom_actuators
+    )
+    fused_actuator_group.initialize(nworld, device)
+    self._fused_actuator_group = fused_actuator_group
+    self._custom_actuators = custom_actuators
+
+    # Root state.
+    default_root_state = self._build_default_root_state(nworld, device)
+
+    # Joint state.
+    if self.is_articulated:
+      if self.cfg.init_state.joint_pos is None:
+        # Use keyframe joint positions.
+        key_qpos = mj_model.key("init_state").qpos
+        nq_root = 7 if not self.is_fixed_base else 0
+        default_joint_pos = torch.tensor(key_qpos[nq_root:], device=device)[
+          None
+        ].repeat(nworld, 1)
+      else:
+        default_joint_pos = torch.tensor(
+          resolve_expr(self.cfg.init_state.joint_pos, self.joint_names, 0.0),
+          device=device,
+        )[None].repeat(nworld, 1)
+      default_joint_vel = torch.tensor(
+        resolve_expr(self.cfg.init_state.joint_vel, self.joint_names, 0.0),
+        device=device,
+      )[None].repeat(nworld, 1)
+
+      # Joint limits.
+      joint_ids_list = [j.id for j in self._non_free_joints]
+      dof_limits = model.jnt_range[:, joint_ids_list]
+      default_joint_pos_limits = dof_limits.clone()
+      joint_pos_limits = default_joint_pos_limits.clone()
+
+      joint_pos_mean = (joint_pos_limits[..., 0] + joint_pos_limits[..., 1]) / 2
+      joint_pos_range = joint_pos_limits[..., 1] - joint_pos_limits[..., 0]
+
+      # Soft limits.
+      soft_limit_factor = (
+        self.cfg.articulation.soft_joint_pos_limit_factor
+        if self.cfg.articulation
+        else 1.0
+      )
+      soft_joint_pos_limits = torch.stack(
+        [
+          joint_pos_mean - 0.5 * joint_pos_range * soft_limit_factor,
+          joint_pos_mean + 0.5 * joint_pos_range * soft_limit_factor,
+        ],
+        dim=-1,
+      )
+
+      # Unlimited joints have jnt_range=[0,0] in MuJoCo, which makes all
+      # the computed limits [0,0]. Override to [-inf, inf] so downstream
+      # clamping becomes a no-op. (Can't do this before soft-limit math
+      # because inf - inf = NaN.)
+      unlimited = ~torch.tensor(
+        mj_model.jnt_limited[joint_ids_list], device=device, dtype=torch.bool
+      )
+      for limits in (joint_pos_limits, default_joint_pos_limits, soft_joint_pos_limits):
+        limits[:, unlimited, 0] = float("-inf")
+        limits[:, unlimited, 1] = float("inf")
+    else:
+      empty_shape = (nworld, 0)
+      default_joint_pos = torch.empty(*empty_shape, dtype=torch.float, device=device)
+      default_joint_vel = torch.empty(*empty_shape, dtype=torch.float, device=device)
+      default_joint_pos_limits = torch.empty(
+        *empty_shape, 2, dtype=torch.float, device=device
+      )
+      joint_pos_limits = torch.empty(*empty_shape, 2, dtype=torch.float, device=device)
+      soft_joint_pos_limits = torch.empty(
+        *empty_shape, 2, dtype=torch.float, device=device
+      )
+
+    if self.is_actuated:
+      joint_pos_target = torch.zeros(
+        (nworld, self.num_joints), dtype=torch.float, device=device
+      )
+      joint_vel_target = torch.zeros(
+        (nworld, self.num_joints), dtype=torch.float, device=device
+      )
+      joint_effort_target = torch.zeros(
+        (nworld, self.num_joints), dtype=torch.float, device=device
+      )
+    else:
+      joint_pos_target = torch.empty(nworld, 0, dtype=torch.float, device=device)
+      joint_vel_target = torch.empty(nworld, 0, dtype=torch.float, device=device)
+      joint_effort_target = torch.empty(nworld, 0, dtype=torch.float, device=device)
+
+    # Only allocate tendon targets if there are actuators using tendon transmission.
+    if self.has_tendon_actuators:
+      num_tendons = len(self.tendon_names)
+      tendon_len_target = torch.zeros(
+        (nworld, num_tendons), dtype=torch.float, device=device
+      )
+      tendon_vel_target = torch.zeros(
+        (nworld, num_tendons), dtype=torch.float, device=device
+      )
+      tendon_effort_target = torch.zeros(
+        (nworld, num_tendons), dtype=torch.float, device=device
+      )
+    else:
+      tendon_len_target = torch.empty(nworld, 0, dtype=torch.float, device=device)
+      tendon_vel_target = torch.empty(nworld, 0, dtype=torch.float, device=device)
+      tendon_effort_target = torch.empty(nworld, 0, dtype=torch.float, device=device)
+
+    # Only allocate site targets if there are actuators using site transmission.
+    if self.has_site_actuators:
+      num_sites = len(self.site_names)
+      site_effort_target = torch.zeros(
+        (nworld, num_sites), dtype=torch.float, device=device
+      )
+    else:
+      site_effort_target = torch.empty(nworld, 0, dtype=torch.float, device=device)
+
+    # Encoder bias for simulating encoder calibration errors.
+    # Shape: (num_envs, num_joints). Defaults to zero (no bias).
+    if self.is_articulated:
+      encoder_bias = torch.zeros(
+        (nworld, self.num_joints), dtype=torch.float, device=device
+      )
+    else:
+      encoder_bias = torch.empty(nworld, 0, dtype=torch.float, device=device)
+
+    self._data = EntityData(
+      indexing=indexing,
+      data=data,
+      model=model,
+      device=device,
+      default_root_state=default_root_state,
+      default_joint_pos=default_joint_pos,
+      default_joint_vel=default_joint_vel,
+      default_joint_pos_limits=default_joint_pos_limits,
+      joint_pos_limits=joint_pos_limits,
+      soft_joint_pos_limits=soft_joint_pos_limits,
+      gravity_vec_w=torch.tensor([0.0, 0.0, -1.0], device=device).repeat(nworld, 1),
+      forward_vec_b=torch.tensor([1.0, 0.0, 0.0], device=device).repeat(nworld, 1),
+      is_fixed_base=self.is_fixed_base,
+      is_articulated=self.is_articulated,
+      is_actuated=self.is_actuated,
+      joint_pos_target=joint_pos_target,
+      joint_vel_target=joint_vel_target,
+      joint_effort_target=joint_effort_target,
+      tendon_len_target=tendon_len_target,
+      tendon_vel_target=tendon_vel_target,
+      tendon_effort_target=tendon_effort_target,
+      site_effort_target=site_effort_target,
+      encoder_bias=encoder_bias,
+    )
+
+  def update(self, dt: float) -> None:
+    """Advance actuator internal state by one physics substep.
+
+    Called after each ``sim.step()`` within the decimation loop.
+    """
+    for act in self._actuators:
+      act.update(dt)
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    """Zero actuator targets and reset actuator internal state.
+
+    Called by the scene when environments are reset at episode boundaries,
+    and by commands that teleport the robot to a new pose mid-episode.
+    """
+    self._data.clear_state(env_ids)
+
+    for act in self._actuators:
+      act.reset(env_ids)
+
+  def clear_state(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    """Deprecated. Use ``reset`` instead."""
+    warnings.warn(
+      "Entity.clear_state() is deprecated. Use Entity.reset().",
+      DeprecationWarning,
+      stacklevel=2,
+    )
+    self.reset(env_ids)
+
+  def write_data_to_sim(self) -> None:
+    """Convert actuator targets into low-level controls and write them to the sim.
+
+    Called before each ``sim.step()`` within the decimation loop. Builtin actuators are
+    applied in a single batched operation; custom actuators are applied individually.
+    """
+    self._apply_actuator_controls()
+
+  def write_ctrl_to_sim(
+    self,
+    ctrl: torch.Tensor,
+    ctrl_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Write control inputs to the simulation.
+
+    Args:
+      ctrl: A tensor of control inputs.
+      ctrl_ids: A tensor of control indices.
+      env_ids: Optional tensor or slice specifying which environments to set.
+        If None, all environments are set.
+    """
+    self._data.write_ctrl(ctrl, ctrl_ids, env_ids)
+
+  def write_root_state_to_sim(
+    self, root_state: torch.Tensor, env_ids: torch.Tensor | slice | None = None
+  ) -> None:
+    """Set the root state into the simulation.
+
+    The root state consists of position (3), orientation as a (w, x, y, z)
+    quaternion (4), linear velocity (3), and angular velocity (3), for a total
+    of 13 values. All of the quantities are in the world frame.
+
+    Args:
+      root_state: Tensor of shape (N, 13) where N is the number of environments.
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+    """
+    self._data.write_root_state(root_state, env_ids)
+
+  def write_root_link_pose_to_sim(
+    self,
+    root_pose: torch.Tensor,
+    env_ids: torch.Tensor | slice | None = None,
+  ):
+    """Set the root pose into the simulation. Like `write_root_state_to_sim()`
+    but only sets position and orientation.
+
+    Args:
+      root_pose: Tensor of shape (N, 7) where N is the number of environments.
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+    """
+    self._data.write_root_pose(root_pose, env_ids)
+
+  def write_root_link_velocity_to_sim(
+    self,
+    root_velocity: torch.Tensor,
+    env_ids: torch.Tensor | slice | None = None,
+  ):
+    """Set the root link (body origin) velocity into the simulation. Like
+    `write_root_state_to_sim()` but only sets linear and angular velocity.
+
+    Args:
+      root_velocity: Tensor of shape (N, 6) where N is the number of environments.
+        Contains linear velocity (3) at body origin and angular velocity (3),
+        both in world frame.
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+    """
+    self._data.write_root_velocity(root_velocity, env_ids)
+
+  def write_root_link_velocity_b_to_sim(
+    self,
+    root_velocity_b: torch.Tensor,
+    env_ids: torch.Tensor | slice | None = None,
+  ):
+    """Like `write_root_link_velocity_to_sim()` but the velocity is expressed
+    in the root link's body frame. Reads the orientation from qpos, so it is
+    safe to call during a reset before forward() runs.
+
+    Args:
+      root_velocity_b: Tensor of shape (N, 6) where N is the number of
+        environments. Contains linear velocity (3) at body origin and angular
+        velocity (3), both in the root link's body frame.
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+    """
+    self._data.write_root_velocity_b(root_velocity_b, env_ids)
+
+  def write_root_com_velocity_to_sim(
+    self,
+    root_velocity: torch.Tensor,
+    env_ids: torch.Tensor | slice | None = None,
+  ):
+    """Set the root COM velocity into the simulation.
+
+    Args:
+      root_velocity: Tensor of shape (N, 6) where N is the number of environments.
+        Contains linear velocity (3) at COM and angular velocity (3),
+        both in world frame.
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+    """
+    self._data.write_root_com_velocity(root_velocity, env_ids)
+
+  def write_joint_state_to_sim(
+    self,
+    position: torch.Tensor,
+    velocity: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ):
+    """Set the joint state into the simulation.
+
+    The joint state consists of joint positions and velocities. It does not include
+    the root state.
+
+    Args:
+      position: Tensor of shape (N, num_joints) where N is the number of environments.
+      velocity: Tensor of shape (N, num_joints) where N is the number of environments.
+      joint_ids: Optional tensor or slice specifying which joints to set. If None,
+        all joints are set.
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+    """
+    self._data.write_joint_state(position, velocity, joint_ids, env_ids)
+
+  def write_joint_position_to_sim(
+    self,
+    position: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ):
+    """Set the joint positions into the simulation. Like `write_joint_state_to_sim()`
+    but only sets joint positions.
+
+    Args:
+      position: Tensor of shape (N, num_joints) where N is the number of environments.
+      joint_ids: Optional tensor or slice specifying which joints to set. If None,
+        all joints are set.
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+    """
+    self._data.write_joint_position(position, joint_ids, env_ids)
+
+  def write_joint_velocity_to_sim(
+    self,
+    velocity: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ):
+    """Set the joint velocities into the simulation. Like `write_joint_state_to_sim()`
+    but only sets joint velocities.
+
+    Args:
+      velocity: Tensor of shape (N, num_joints) where N is the number of environments.
+      joint_ids: Optional tensor or slice specifying which joints to set. If None,
+        all joints are set.
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+    """
+    self._data.write_joint_velocity(velocity, joint_ids, env_ids)
+
+  def set_joint_position_target(
+    self,
+    position: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set joint position targets.
+
+    Args:
+      position: Target joint poisitions with shape (N, num_joints).
+      joint_ids: Optional joint indices to set. If None, set all joints.
+      env_ids: Optional environment indices. If None, set all environments.
+    """
+    if env_ids is None:
+      env_ids = slice(None)
+    if joint_ids is None:
+      joint_ids = slice(None)
+    env_ids, joint_ids = _outer_index(env_ids, joint_ids)
+    self._data.joint_pos_target[env_ids, joint_ids] = position
+
+  def set_joint_velocity_target(
+    self,
+    velocity: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set joint velocity targets.
+
+    Args:
+      velocity: Target joint velocities with shape (N, num_joints).
+      joint_ids: Optional joint indices to set. If None, set all joints.
+      env_ids: Optional environment indices. If None, set all environments.
+    """
+    if env_ids is None:
+      env_ids = slice(None)
+    if joint_ids is None:
+      joint_ids = slice(None)
+    env_ids, joint_ids = _outer_index(env_ids, joint_ids)
+    self._data.joint_vel_target[env_ids, joint_ids] = velocity
+
+  def set_joint_effort_target(
+    self,
+    effort: torch.Tensor,
+    joint_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set joint effort targets.
+
+    Args:
+      effort: Target joint efforts with shape (N, num_joints).
+      joint_ids: Optional joint indices to set. If None, set all joints.
+      env_ids: Optional environment indices. If None, set all environments.
+    """
+    if env_ids is None:
+      env_ids = slice(None)
+    if joint_ids is None:
+      joint_ids = slice(None)
+    env_ids, joint_ids = _outer_index(env_ids, joint_ids)
+    self._data.joint_effort_target[env_ids, joint_ids] = effort
+
+  def set_tendon_len_target(
+    self,
+    length: torch.Tensor,
+    tendon_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set tendon length targets.
+
+    Args:
+      length: Target tendon lengths with shape (N, num_tendons).
+      tendon_ids: Optional tendon indices to set. If None, set all tendons.
+      env_ids: Optional environment indices. If None, set all environments.
+    """
+    if env_ids is None:
+      env_ids = slice(None)
+    if tendon_ids is None:
+      tendon_ids = slice(None)
+    env_ids, tendon_ids = _outer_index(env_ids, tendon_ids)
+    self._data.tendon_len_target[env_ids, tendon_ids] = length
+
+  def set_tendon_vel_target(
+    self,
+    velocity: torch.Tensor,
+    tendon_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set tendon velocity targets.
+
+    Args:
+      velocity: Target tendon velocities with shape (N, num_tendons).
+      tendon_ids: Optional tendon indices to set. If None, set all tendons.
+      env_ids: Optional environment indices. If None, set all environments.
+    """
+    if env_ids is None:
+      env_ids = slice(None)
+    if tendon_ids is None:
+      tendon_ids = slice(None)
+    env_ids, tendon_ids = _outer_index(env_ids, tendon_ids)
+    self._data.tendon_vel_target[env_ids, tendon_ids] = velocity
+
+  def set_tendon_effort_target(
+    self,
+    effort: torch.Tensor,
+    tendon_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set tendon effort targets.
+
+    Args:
+      effort: Target tendon efforts with shape (N, num_tendons).
+      tendon_ids: Optional tendon indices to set. If None, set all tendons.
+      env_ids: Optional environment indices. If None, set all environments.
+    """
+    if env_ids is None:
+      env_ids = slice(None)
+    if tendon_ids is None:
+      tendon_ids = slice(None)
+    env_ids, tendon_ids = _outer_index(env_ids, tendon_ids)
+    self._data.tendon_effort_target[env_ids, tendon_ids] = effort
+
+  def set_site_effort_target(
+    self,
+    effort: torch.Tensor,
+    site_ids: torch.Tensor | slice | None = None,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set site effort targets.
+
+    Args:
+      effort: Target site efforts with shape (N, num_sites).
+      site_ids: Optional site indices to set. If None, set all sites.
+      env_ids: Optional environment indices. If None, set all environments.
+    """
+    if env_ids is None:
+      env_ids = slice(None)
+    if site_ids is None:
+      site_ids = slice(None)
+    env_ids, site_ids = _outer_index(env_ids, site_ids)
+    self._data.site_effort_target[env_ids, site_ids] = effort
+
+  def write_external_wrench_to_sim(
+    self,
+    forces: torch.Tensor,
+    torques: torch.Tensor,
+    env_ids: torch.Tensor | slice | None = None,
+    body_ids: Sequence[int] | slice | None = None,
+  ) -> None:
+    """Apply external wrenches to bodies in the simulation.
+
+    Underneath the hood, this sets the `xfrc_applied` field in the MuJoCo data
+    structure. The wrenches are specified in the world frame and persist until
+    the next call to this function or until the simulation is reset.
+
+    Args:
+      forces: Tensor of shape (N, num_bodies, 3) where N is the number of
+        environments.
+      torques: Tensor of shape (N, num_bodies, 3) where N is the number of
+        environments.
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+      body_ids: Optional list of body indices or slice specifying which bodies to
+        apply the wrenches to. If None, wrenches are applied to all bodies.
+    """
+    self._data.write_external_wrench(forces, torques, body_ids, env_ids)
+
+  def write_mocap_pose_to_sim(
+    self,
+    mocap_pose: torch.Tensor,
+    env_ids: torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set the pose of a mocap body into the simulation.
+
+    Args:
+      mocap_pose: Tensor of shape (N, 7) where N is the number of environments.
+        Format: [pos_x, pos_y, pos_z, quat_w, quat_x, quat_y, quat_z]
+      env_ids: Optional tensor or slice specifying which environments to set. If
+        None, all environments are set.
+    """
+    self._data.write_mocap_pose(mocap_pose, env_ids)
+
+  ##
+  # Private methods.
+  ##
+
+  def _build_default_root_state(self, nworld: int, device: str) -> torch.Tensor:
+    """Build default root state tensor, uniform across all worlds."""
+    base = self.cfg.init_state
+    components: list[tuple[float, ...]] = [base.pos, base.rot]
+    if not self.is_fixed_base:
+      components.extend([base.lin_vel, base.ang_vel])
+    return torch.tensor(
+      sum((tuple(c) for c in components), ()),
+      dtype=torch.float,
+      device=device,
+    ).repeat(nworld, 1)
+
+  def _compute_indexing(self, model: mujoco.MjModel, device: str) -> EntityIndexing:
+    bodies = tuple([b for b in self.spec.bodies[1:]])
+    joints = self._non_free_joints
+    geoms = tuple(self.spec.geoms)
+    sites = tuple(self.spec.sites)
+    tendons = tuple(self.spec.tendons)
+    cameras = tuple(self.spec.cameras)
+    lights = tuple(self.spec.lights)
+    materials = tuple(self.spec.materials)
+    textures = tuple(self.spec.textures)
+    pairs = tuple(self.spec.pairs)
+
+    body_ids = torch.tensor([b.id for b in bodies], dtype=torch.int, device=device)
+    geom_ids = torch.tensor([g.id for g in geoms], dtype=torch.int, device=device)
+    site_ids = torch.tensor([s.id for s in sites], dtype=torch.int, device=device)
+    tendon_ids = torch.tensor([t.id for t in tendons], dtype=torch.int, device=device)
+    cam_ids = torch.tensor([c.id for c in cameras], dtype=torch.int, device=device)
+    light_ids = torch.tensor([lt.id for lt in lights], dtype=torch.int, device=device)
+    mat_ids = torch.tensor([m.id for m in materials], dtype=torch.int, device=device)
+    tex_ids = torch.tensor([t.id for t in textures], dtype=torch.int, device=device)
+    pair_ids = torch.tensor([p.id for p in pairs], dtype=torch.int, device=device)
+    joint_ids = torch.tensor([j.id for j in joints], dtype=torch.int, device=device)
+
+    if self.is_actuated:
+      actuators = tuple(self.spec.actuators)
+      ctrl_ids = torch.tensor([a.id for a in actuators], dtype=torch.int, device=device)
+    else:
+      actuators = None
+      ctrl_ids = torch.empty(0, dtype=torch.int, device=device)
+
+    joint_q_adr = []
+    joint_v_adr = []
+    free_joint_q_adr = []
+    free_joint_v_adr = []
+    for joint in self.spec.joints:
+      jnt = model.joint(joint.name)
+      jnt_type = jnt.type[0]
+      vadr = jnt.dofadr[0]
+      qadr = jnt.qposadr[0]
+      if jnt_type == mujoco.mjtJoint.mjJNT_FREE:
+        free_joint_v_adr.extend(range(vadr, vadr + 6))
+        free_joint_q_adr.extend(range(qadr, qadr + 7))
+      else:
+        joint_v_adr.extend(range(vadr, vadr + dof_width(jnt_type)))
+        joint_q_adr.extend(range(qadr, qadr + qpos_width(jnt_type)))
+    joint_q_adr = torch.tensor(joint_q_adr, dtype=torch.int, device=device)
+    joint_v_adr = torch.tensor(joint_v_adr, dtype=torch.int, device=device)
+    free_joint_v_adr = torch.tensor(free_joint_v_adr, dtype=torch.int, device=device)
+    free_joint_q_adr = torch.tensor(free_joint_q_adr, dtype=torch.int, device=device)
+
+    if self.is_fixed_base and self.is_mocap:
+      mocap_id = int(model.body_mocapid[self.root_body.id])
+    else:
+      mocap_id = None
+
+    return EntityIndexing(
+      bodies=bodies,
+      joints=joints,
+      geoms=geoms,
+      sites=sites,
+      tendons=tendons,
+      cameras=cameras,
+      lights=lights,
+      materials=materials,
+      textures=textures,
+      pairs=pairs,
+      actuators=actuators,
+      body_ids=body_ids,
+      geom_ids=geom_ids,
+      site_ids=site_ids,
+      tendon_ids=tendon_ids,
+      cam_ids=cam_ids,
+      light_ids=light_ids,
+      mat_ids=mat_ids,
+      tex_ids=tex_ids,
+      pair_ids=pair_ids,
+      ctrl_ids=ctrl_ids,
+      joint_ids=joint_ids,
+      mocap_id=mocap_id,
+      joint_q_adr=joint_q_adr,
+      joint_v_adr=joint_v_adr,
+      free_joint_q_adr=free_joint_q_adr,
+      free_joint_v_adr=free_joint_v_adr,
+    )
+
+  def _apply_actuator_controls(self) -> None:
+    self._builtin_group.apply_controls(self._data)
+    self._fused_actuator_group.apply_controls(self._data)
+    for act in self._custom_actuators:
+      command = act.get_command(self._data)
+      command = act.apply_delay(command)
+      self._data.write_ctrl(act.compute(command), act.ctrl_ids)
diff --git a/src/mjlab/entity/variants.py b/src/mjlab/entity/variants.py
new file mode 100644
index 0000000..f867f2b
--- /dev/null
+++ b/src/mjlab/entity/variants.py
@@ -0,0 +1,1442 @@
+"""Per-world mesh variant support.
+
+A single batched simulation can run with different mesh assets in different
+parallel worlds. World 0 may simulate a cube, world 1 a sphere, world 2 a
+bowl, all sharing the same compiled scene and the same kinematic structure.
+The result is a heterogeneous batch in which the mesh and its derived
+constants vary across worlds while everything else (body tree, joint
+structure, contact and solver setup) is fixed.
+
+The feature spans two phases, both of which live in this file:
+
+1. **Authoring** (entity-build time, MjSpec only). The user supplies a
+   ``VariantEntityCfg`` whose ``variants`` map names to spec callables
+   instances, each with its own ``spec_fn``. ``build_merged_variant_spec``
+   validates that all source specs share kinematic topology, computes
+   ``(body_path, role, ordinal)`` slots so each variable mesh geom has a
+   structural identity, and merges the source specs into one padded
+   template spec. It returns ``(template_spec, VariantMetadata)``.
+2. **Realization** (sim-init time, mujoco_warp). ``build_variant_model``
+   takes the scene-attached padded spec plus the per-entity
+   ``VariantMetadata`` and produces a heterogeneous Warp model: a per-world
+   ``geom_dataid`` table plus per-world arrays for the geometry-dependent
+   fields listed in ``VARIANT_DEPENDENT_FIELDS``. Each unique variant is
+   compiled once on the host with its source-spec geom semantics restored,
+   and the resulting reference fields are scattered into per-world arrays
+   keyed by world-to-variant assignment.
+
+Slot identity is the throughline. ``SlotKey(body_path, role, ordinal)`` is
+fixed across variants because mujoco_warp's ``geom_contype``/
+``geom_conaffinity`` are 1D shared, so each slot's role (visual vs
+collision) cannot change per world. ``VariantGeomSpec`` records each
+variant's source-geom attributes per slot so the per-variant reference
+compile restores them verbatim instead of inheriting whatever the template
+variant set.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+from typing import Any, Callable, Literal, Sequence, cast
+
+import mujoco
+import mujoco_warp as mjwarp
+import numpy as np
+import warp as wp
+
+from mjlab.entity.entity import EntityCfg
+from mjlab.utils.mujoco import dof_width, qpos_width
+from mjlab.utils.spec import copy_material_data, copy_mesh_data, copy_texture_data
+
+# Reserved name prefixes for synthesized template entities. Source variant
+# specs must not create geoms, bodies, meshes, or other named items under
+# these prefixes; validation rejects them so the merge pass can introduce
+# padding geoms without colliding with user names.
+RESERVED_NAME_PREFIXES: tuple[str, ...] = ("mjlab/pad/",)
+
+# Fields that depend on mesh geometry and must be compiled per-variant.
+VARIANT_DEPENDENT_FIELDS = (
+  "geom_size",
+  "geom_rbound",
+  "geom_aabb",
+  "geom_pos",
+  "geom_quat",
+  "body_mass",
+  "body_subtreemass",
+  "body_inertia",
+  "body_invweight0",
+  "body_ipos",
+  "body_iquat",
+)
+
+GeomRole = Literal["visual", "collision"]
+InertialMode = Literal["mesh-derived", "diagonal", "fullinertia"]
+
+
+##
+# Input: what the user writes.
+##
+
+
+def _variant_spec_fn_unset() -> mujoco.MjSpec:
+  """Sentinel default for ``VariantEntityCfg.spec_fn``.
+
+  ``VariantEntityCfg`` builds its spec from ``variants`` via
+  ``build_merged_variant_spec``; the inherited ``spec_fn`` field is unused.
+  Identity comparison against this sentinel detects accidental user overrides.
+  """
+  raise AssertionError(
+    "VariantEntityCfg.spec_fn should never be called; the merged spec is "
+    "built from `variants`."
+  )
+
+
+@dataclass
+class VariantEntityCfg(EntityCfg):
+  """Entity config for per-world mesh variants.
+
+  Provide a dict of named variants (each value is a callable returning
+  an ``MjSpec``) and optionally an ``assignment`` describing how worlds
+  map to variants. The merged spec (with all variant meshes and padded
+  geoms) is built automatically.
+
+  All variants must share the same kinematic structure (same bodies,
+  joints, joint types). Only mesh geoms can differ.
+
+  Variant assignment is fixed at ``Simulation`` initialization; it does
+  not resample on episode reset.
+  """
+
+  variants: dict[str, Callable[[], mujoco.MjSpec]] = field(default_factory=dict)
+  """Named mesh variants. Each value is a callable returning an ``MjSpec``."""
+
+  assignment: dict[str, float] | Callable[[int], Sequence[int]] | None = None
+  """How worlds get mapped to variants. Three shapes:
+
+  * ``None`` (default): uniform allocation across variants via
+    largest-remainder.
+  * ``dict[str, float]``: per-variant weights for largest-remainder
+    allocation. Variants not listed default to weight 1.0.
+  * ``Callable[[int], Sequence[int]]``: an explicit assignment
+    function, called with ``num_envs`` at simulation init and required
+    to return a length-``num_envs`` sequence of variant indices in
+    ``[0, len(variants))``."""
+
+  spec_fn: Callable[[], mujoco.MjSpec] = field(default=_variant_spec_fn_unset)
+  """Unused on ``VariantEntityCfg``; the merged spec is built from ``variants``."""
+
+  def __post_init__(self) -> None:
+    if self.spec_fn is not _variant_spec_fn_unset:
+      raise ValueError(
+        "VariantEntityCfg.spec_fn cannot be set; pass per-variant spec "
+        "callables in `variants` instead."
+      )
+    if isinstance(self.assignment, dict):
+      extras = set(self.assignment) - set(self.variants)
+      if extras:
+        raise ValueError(
+          f"VariantEntityCfg.assignment has keys not present in variants: "
+          f"{sorted(extras)}."
+        )
+
+
+##
+# Output: data records that flow to scene/sim.
+##
+
+
+@dataclass(frozen=True)
+class SlotKey:
+  """Structural identity of a mesh slot in the merged template."""
+
+  body_path: str
+  role: GeomRole
+  ordinal: int
+
+
+@dataclass(frozen=True)
+class VariantGeomSpec:
+  """Per-variant per-slot geom attributes captured from the source spec.
+
+  The slot-aware merge uses this to restore exact source semantics
+  (contact bits, friction, material, etc.) for each variant's reference
+  compilation, instead of inheriting whatever the template variant set.
+  """
+
+  mesh_name: str
+  geom_name: str | None
+  contype: int
+  conaffinity: int
+  condim: int
+  group: int
+  priority: int
+  material: str | None
+  rgba: tuple[float, float, float, float]
+  friction: tuple[float, float, float]
+  margin: float
+  gap: float
+  solref: tuple[float, float]
+  solimp: tuple[float, float, float, float, float]
+  # ``mass``/``density`` default to 0.0 in the source spec, which MuJoCo
+  # interprets as "infer from mesh volume". The slot-aware compile path
+  # passes the source value through verbatim.
+  mass: float
+  density: float
+
+
+@dataclass(frozen=True)
+class VariantSlot:
+  """One slot in the merged template body.
+
+  ``template_geom_name`` is the synthesized name on the template body's
+  geom that backs this slot. It always uses the reserved
+  ``mjlab/pad/<body_path>/<role>/<ordinal>`` prefix so it cannot
+  collide with user-named source geoms (validation rejects user geoms
+  starting with ``mjlab/pad/``).
+
+  ``source_geom_names`` records, per variant, the original source geom
+  name for diagnostics. ``None`` here can mean either "variant doesn't
+  fill the slot" or "variant fills the slot with an unnamed geom"; the
+  authoritative source for fill status is
+  ``VariantMetadata.variant_slot_specs[v][s] is None``.
+  """
+
+  key: SlotKey
+  template_geom_name: str
+  source_geom_names: tuple[str | None, ...]
+
+
+@dataclass
+class VariantMetadata:
+  """Bookkeeping produced when merging variant specs.
+
+  Slots are ordered by ``(body_path, role, ordinal)`` and
+  ``variant_slot_specs[v]`` aligns positionally with ``slots`` so
+  ``variant_slot_specs[v][s]`` describes how variant ``v`` fills slot
+  ``s`` (``None`` if variant ``v`` leaves the slot unfilled).
+
+  ``variant_source_specs[v]`` is the original ``MjSpec`` produced by
+  variant ``v``'s ``spec_fn`` (pre-merge). The sim-time build path
+  compiles each one in isolation rather than recompiling a copy of the
+  merged scene, which keeps construction cost linear in the number of
+  variants instead of quadratic.
+
+  ``variant_mesh_names`` and ``num_mesh_geoms`` are kept as derived
+  ``@property`` views over ``variant_slot_specs`` for back-compat with
+  consumers that index by slot.
+  """
+
+  variant_names: tuple[str, ...]
+  assignment: tuple[float, ...] | Callable[[int], Sequence[int]] = ()
+  slots: tuple[VariantSlot, ...] = ()
+  variant_slot_specs: tuple[tuple[VariantGeomSpec | None, ...], ...] = ()
+  variant_source_specs: tuple[mujoco.MjSpec, ...] = ()
+
+  @property
+  def variant_mesh_names(self) -> tuple[tuple[str | None, ...], ...]:
+    """Per-variant slot-aligned mesh names with variant prefix.
+
+    ``None`` at position ``s`` means variant ``v`` does not fill slot
+    ``s``. Derived from ``variant_slot_specs``.
+    """
+    return tuple(
+      tuple(
+        None if ss is None else f"{self.variant_names[v_idx]}/{ss.mesh_name}"
+        for ss in slot_specs
+      )
+      for v_idx, slot_specs in enumerate(self.variant_slot_specs)
+    )
+
+  @property
+  def num_mesh_geoms(self) -> int:
+    """Max number of filled mesh slots across variants (i.e. the longest
+    variant's source mesh count). Derived from ``variant_slot_specs``."""
+    if not self.variant_slot_specs:
+      return 0
+    return max(
+      sum(1 for ss in slot_specs if ss is not None)
+      for slot_specs in self.variant_slot_specs
+    )
+
+
+@dataclass
+class MeshVariantResult:
+  """Output of :func:`build_variant_model`."""
+
+  wp_model: mjwarp.Model
+  mj_model: mujoco.MjModel
+  # Maps entity prefix -> array of variant indices per world.
+  world_to_variant: dict[str, np.ndarray]
+
+
+##
+# Tree helpers (shared by validation and slot computation).
+##
+
+
+def _iter_body_paths(
+  body: mujoco.MjsBody, parent_path: str = ""
+) -> list[tuple[str, mujoco.MjsBody]]:
+  """Return ``[(path, body), ...]`` for the recursive body tree.
+
+  Path is the body's path relative to the variant root (e.g. ``/prop``,
+  ``/prop/lid``), built by joining body names with ``/``.
+  """
+  body_name = body.name or ""
+  path = f"{parent_path}/{body_name}"
+  out: list[tuple[str, mujoco.MjsBody]] = [(path, body)]
+  for child in body.bodies:
+    out.extend(_iter_body_paths(child, path))
+  return out
+
+
+def _classify_geom_role(geom: mujoco.MjsGeom) -> GeomRole:
+  """Derive a geom's slot role from its contact bits.
+
+  Visual: ``contype == 0`` and ``conaffinity == 0``. Collision: anything
+  else. Shared by validation and slot computation.
+  """
+  if int(geom.contype) == 0 and int(geom.conaffinity) == 0:
+    return "visual"
+  return "collision"
+
+
+def _iter_body_tree(body: mujoco.MjsBody):
+  yield body
+  for child in body.bodies:
+    yield from _iter_body_tree(child)
+
+
+##
+# Validation pass: cross-variant topology comparison.
+##
+
+
+@dataclass(frozen=True)
+class JointSignature:
+  """Joint identity for cross-variant matching.
+
+  Captures the structural attributes that must match across variants:
+  name, type, and qpos/qvel widths. Parameter attributes (axis, range,
+  stiffness, damping, etc.) are not part of the structural signature;
+  they may legitimately differ across variants once registered as
+  per-world fields.
+  """
+
+  name: str
+  type: int
+  qpos_width: int
+  qvel_width: int
+
+
+@dataclass(frozen=True)
+class GeomSignature:
+  """Geom identity for cross-variant matching.
+
+  ``role`` is derived from ``contype``/``conaffinity``: a geom that
+  participates in any contact pair is "collision"; otherwise "visual".
+  A slot's role is fixed across variants by construction because
+  mujoco_warp's ``geom_contype``/``geom_conaffinity`` are 1D shared.
+  """
+
+  name: str | None
+  type: int
+  role: GeomRole
+
+
+@dataclass(frozen=True)
+class BodySignature:
+  """Recursive body identity for cross-variant matching.
+
+  ``path`` is the body path relative to its variant's worldbody, before
+  any scene-attachment prefix. ``children`` are nested signatures in
+  source order.
+  """
+
+  path: str
+  name: str
+  joints: tuple[JointSignature, ...]
+  geoms: tuple[GeomSignature, ...]
+  children: tuple["BodySignature", ...]
+
+
+def _format_variant_error(
+  variant_name: str, message: str, hint: str | None = None
+) -> str:
+  prefix = f"mjlab.entity: VariantEntityCfg '{variant_name}': "
+  body = message
+  if hint:
+    body += f" Hint: {hint}"
+  return prefix + body
+
+
+def _extract_body_signature(
+  body: mujoco.MjsBody, parent_path: str = ""
+) -> BodySignature:
+  body_name = body.name or ""
+  path = f"{parent_path}/{body_name}"
+  joints: list[JointSignature] = []
+  for j in body.joints:
+    jt = int(j.type)
+    joints.append(
+      JointSignature(
+        name=j.name or "",
+        type=jt,
+        qpos_width=qpos_width(jt),
+        qvel_width=dof_width(jt),
+      )
+    )
+  geoms = tuple(
+    GeomSignature(
+      name=g.name if g.name else None,
+      type=int(g.type),
+      role=_classify_geom_role(g),
+    )
+    for g in body.geoms
+  )
+  children = tuple(_extract_body_signature(child, path) for child in body.bodies)
+  return BodySignature(
+    path=path,
+    name=body_name,
+    joints=tuple(joints),
+    geoms=geoms,
+    children=children,
+  )
+
+
+def _detect_inertial_mode(body: mujoco.MjsBody) -> InertialMode:
+  # `body.fullinertia` defaults to [nan, 0, 0, 0, 0, 0]; a non-NaN first
+  # element means the user assigned fullinertia (any assignment, even
+  # zeros, flips the user-specified flag at compile time).
+  if not math.isnan(float(body.fullinertia[0])):
+    return "fullinertia"
+  if body.explicitinertial:
+    return "diagonal"
+  return "mesh-derived"
+
+
+def _collect_inertial_modes(
+  body: mujoco.MjsBody, parent_path: str = ""
+) -> dict[str, InertialMode]:
+  body_name = body.name or ""
+  path = f"{parent_path}/{body_name}"
+  modes: dict[str, InertialMode] = {path: _detect_inertial_mode(body)}
+  for child in body.bodies:
+    modes.update(_collect_inertial_modes(child, path))
+  return modes
+
+
+def _check_reserved_names(spec: mujoco.MjSpec, variant_name: str) -> None:
+  collections: tuple[tuple[str, str], ...] = (
+    ("bodies", "body"),
+    ("geoms", "geom"),
+    ("meshes", "mesh"),
+    ("materials", "material"),
+    ("textures", "texture"),
+    ("joints", "joint"),
+    ("actuators", "actuator"),
+    ("tendons", "tendon"),
+    ("sensors", "sensor"),
+    ("cameras", "camera"),
+    ("lights", "light"),
+    ("sites", "site"),
+    ("equalities", "equality"),
+  )
+  for attr, item_kind in collections:
+    items = getattr(spec, attr, None)
+    if items is None:
+      continue
+    for item in items:
+      name = getattr(item, "name", None) or ""
+      for prefix in RESERVED_NAME_PREFIXES:
+        if name.startswith(prefix):
+          raise ValueError(
+            _format_variant_error(
+              variant_name,
+              f"reserved name prefix '{prefix}' is used by source "
+              f"{item_kind} '{name}'.",
+              "rename user geoms/bodies/assets away from this prefix.",
+            )
+          )
+
+
+def _compare_geoms_for_body(
+  ref_variant: str,
+  ref_geoms: tuple[GeomSignature, ...],
+  other_variant: str,
+  other_geoms: tuple[GeomSignature, ...],
+  body_path: str,
+) -> None:
+  """Compare geoms within a matching body across two variants.
+
+  Mesh geoms may differ in count per ``(body, role)``; they form padded
+  slots and are not part of the structural signature. Non-mesh
+  primitive geoms must match exactly in count, name, type, role, and
+  ordering relative to other primitives.
+  """
+  mesh_type = int(mujoco.mjtGeom.mjGEOM_MESH)
+  ref_primitives = tuple(g for g in ref_geoms if g.type != mesh_type)
+  other_primitives = tuple(g for g in other_geoms if g.type != mesh_type)
+  if len(ref_primitives) != len(other_primitives):
+    raise ValueError(
+      _format_variant_error(
+        other_variant,
+        f"body '{body_path}' has {len(other_primitives)} non-mesh "
+        f"geoms, but '{ref_variant}' has {len(ref_primitives)}.",
+        "primitive geoms must match across all variants; only mesh "
+        "geom counts may differ.",
+      )
+    )
+  for i, (rp, op) in enumerate(zip(ref_primitives, other_primitives, strict=False)):
+    if rp != op:
+      raise ValueError(
+        _format_variant_error(
+          other_variant,
+          f"body '{body_path}' primitive geom #{i} differs from "
+          f"'{ref_variant}': got {op}, expected {rp}.",
+          "primitive geom name, type, and role must match across variants.",
+        )
+      )
+
+
+def _compare_body_signatures(
+  ref_variant: str,
+  ref: BodySignature,
+  other_variant: str,
+  other: BodySignature,
+) -> None:
+  if ref.path != other.path:
+    raise ValueError(
+      _format_variant_error(
+        other_variant,
+        f"body path '{other.path}' has no counterpart in "
+        f"'{ref_variant}' (expected '{ref.path}').",
+        "variants must share the same recursive body tree with matching body names.",
+      )
+    )
+  if len(ref.joints) != len(other.joints):
+    raise ValueError(
+      _format_variant_error(
+        other_variant,
+        f"body '{other.path}' has {len(other.joints)} joints, but "
+        f"'{ref_variant}' has {len(ref.joints)}.",
+        "variants may change mesh assets, not add/remove joints.",
+      )
+    )
+  for i, (rj, oj) in enumerate(zip(ref.joints, other.joints, strict=False)):
+    if rj != oj:
+      raise ValueError(
+        _format_variant_error(
+          other_variant,
+          f"body '{other.path}' joint #{i} differs from "
+          f"'{ref_variant}': got {oj}, expected {rj}.",
+          "joint name, type, and qpos/qvel width must match across variants.",
+        )
+      )
+  _compare_geoms_for_body(
+    ref_variant, ref.geoms, other_variant, other.geoms, other.path
+  )
+  if len(ref.children) != len(other.children):
+    raise ValueError(
+      _format_variant_error(
+        other_variant,
+        f"body '{other.path}' has {len(other.children)} child bodies, "
+        f"but '{ref_variant}' has {len(ref.children)}.",
+        "variants must share the same recursive body tree.",
+      )
+    )
+  for ref_child, other_child in zip(ref.children, other.children, strict=False):
+    _compare_body_signatures(ref_variant, ref_child, other_variant, other_child)
+
+
+def _compare_inertial_modes(
+  ref_variant: str,
+  ref_modes: dict[str, InertialMode],
+  other_variant: str,
+  other_modes: dict[str, InertialMode],
+) -> None:
+  for path in sorted(set(ref_modes) | set(other_modes)):
+    rm = ref_modes.get(path)
+    om = other_modes.get(path)
+    if rm is None or om is None:
+      # Path mismatch is reported by the body-tree comparison.
+      continue
+    if rm != om:
+      raise ValueError(
+        _format_variant_error(
+          other_variant,
+          f"body '{path}' uses inertial representation '{om}', but "
+          f"'{ref_variant}' uses '{rm}'.",
+          "use the same inertial representation in every variant: "
+          "all diagonal, all fullinertia, or all mesh-derived.",
+        )
+      )
+
+
+def _compare_collection_topology(
+  *,
+  item_kind: str,
+  ref_variant: str,
+  ref_items: list[Any],
+  other_variant: str,
+  other_items: list[Any],
+  key_fn: Callable[[Any], tuple],
+  count_hint: str,
+  item_hint: str,
+) -> None:
+  """Compare a flat spec-level collection (actuators, sensors, ...).
+
+  Length must match; per-element ``key_fn(item)`` tuples must match.
+  Per-collection error specificity is preserved through ``item_kind``,
+  ``count_hint``, and ``item_hint`` strings supplied by the caller.
+  """
+  if len(ref_items) != len(other_items):
+    raise ValueError(
+      _format_variant_error(
+        other_variant,
+        f"{item_kind} count {len(other_items)} differs from "
+        f"'{ref_variant}' ({len(ref_items)}).",
+        count_hint,
+      )
+    )
+  for i, (r, o) in enumerate(zip(ref_items, other_items, strict=False)):
+    rk, ok = key_fn(r), key_fn(o)
+    if rk != ok:
+      raise ValueError(
+        _format_variant_error(
+          other_variant,
+          f"{item_kind} #{i} differs from '{ref_variant}': got {ok}, expected {rk}.",
+          item_hint,
+        )
+      )
+
+
+def _actuator_key(a: mujoco.MjsActuator) -> tuple[str, int, str]:
+  return (a.name or "", int(a.trntype), a.target or "")
+
+
+def _sensor_key(s: mujoco.MjsSensor) -> tuple[str, int, int, str]:
+  return (s.name or "", int(s.type), int(s.objtype), s.objname or "")
+
+
+def _tendon_key(t: mujoco.MjsTendon) -> tuple[str]:
+  return (t.name or "",)
+
+
+def _equality_key(e: mujoco.MjsEquality) -> tuple[str, int, str, str]:
+  return (e.name or "", int(e.type), e.name1 or "", e.name2 or "")
+
+
+def validate_variant_specs(
+  names: list[str],
+  specs: list[mujoco.MjSpec],
+) -> None:
+  """Validate that all variant specs share the same kinematic topology.
+
+  Performs recursive body-tree, joint, and primitive-geom comparison;
+  spec-level actuator/sensor/tendon/equality topology comparison;
+  per-body inertial-mode consistency; and reserved-name-prefix
+  rejection. Raises ``ValueError`` with a message of the form:
+
+      mjlab.entity: VariantEntityCfg '<name>': <reason>. Hint: <fix>.
+
+  Mesh geom counts may differ per ``(body, role)``; this is the
+  intended source of variant-to-variant variation. Primitive (non-mesh)
+  geom counts and structure must match.
+
+  Args:
+    names: Variant names. Must be non-empty and align with ``specs``.
+    specs: Variant specs (pre-attachment). Each must have exactly one
+      root body under worldbody.
+  """
+  if len(names) != len(specs):
+    raise ValueError("names and specs must have the same length.")
+  if not names:
+    raise ValueError("at least one variant is required.")
+
+  for name, spec in zip(names, specs, strict=False):
+    _check_reserved_names(spec, name)
+
+  root_bodies: list[mujoco.MjsBody] = []
+  for name, spec in zip(names, specs, strict=False):
+    children = list(spec.worldbody.bodies)
+    if len(children) != 1:
+      raise ValueError(
+        _format_variant_error(
+          name,
+          f"variant must have exactly one root body under worldbody, "
+          f"got {len(children)}.",
+          "place the variant's root body directly under worldbody.",
+        )
+      )
+    root_bodies.append(children[0])
+
+  ref_name = names[0]
+  ref_signature = _extract_body_signature(root_bodies[0])
+  ref_modes = _collect_inertial_modes(root_bodies[0])
+  ref_spec = specs[0]
+
+  for i in range(1, len(names)):
+    other_name = names[i]
+    other_signature = _extract_body_signature(root_bodies[i])
+    other_modes = _collect_inertial_modes(root_bodies[i])
+    other_spec = specs[i]
+
+    _compare_body_signatures(ref_name, ref_signature, other_name, other_signature)
+    _compare_inertial_modes(ref_name, ref_modes, other_name, other_modes)
+    _compare_collection_topology(
+      item_kind="actuator",
+      ref_variant=ref_name,
+      ref_items=list(ref_spec.actuators),
+      other_variant=other_name,
+      other_items=list(other_spec.actuators),
+      key_fn=_actuator_key,
+      count_hint="keep control and observation dimensions fixed across variants.",
+      item_hint=(
+        "actuator topology (name, transmission type, target) must match "
+        "across variants."
+      ),
+    )
+    _compare_collection_topology(
+      item_kind="sensor",
+      ref_variant=ref_name,
+      ref_items=list(ref_spec.sensors),
+      other_variant=other_name,
+      other_items=list(other_spec.sensors),
+      key_fn=_sensor_key,
+      count_hint="keep sensor topology identical across variants.",
+      item_hint="sensor topology (name, type, target object) must match.",
+    )
+    _compare_collection_topology(
+      item_kind="tendon",
+      ref_variant=ref_name,
+      ref_items=list(ref_spec.tendons),
+      other_variant=other_name,
+      other_items=list(other_spec.tendons),
+      key_fn=_tendon_key,
+      count_hint="keep tendon topology identical across variants.",
+      item_hint="tendon names must match across variants.",
+    )
+    _compare_collection_topology(
+      item_kind="equality",
+      ref_variant=ref_name,
+      ref_items=list(ref_spec.equalities),
+      other_variant=other_name,
+      other_items=list(other_spec.equalities),
+      key_fn=_equality_key,
+      count_hint="keep equality constraints identical across variants.",
+      item_hint="equality constraint topology must match across variants.",
+    )
+
+
+##
+# Slot computation: assign (body_path, role, ordinal) keys to mesh geoms.
+##
+
+
+def _extract_variant_geom_spec(g: mujoco.MjsGeom) -> VariantGeomSpec:
+  """Snapshot a source mesh geom's attributes for slot-aware compile."""
+  return VariantGeomSpec(
+    mesh_name=g.meshname,
+    geom_name=g.name if g.name else None,
+    contype=int(g.contype),
+    conaffinity=int(g.conaffinity),
+    condim=int(g.condim),
+    group=int(g.group),
+    priority=int(g.priority),
+    material=g.material if g.material else None,
+    rgba=(
+      float(g.rgba[0]),
+      float(g.rgba[1]),
+      float(g.rgba[2]),
+      float(g.rgba[3]),
+    ),
+    friction=(
+      float(g.friction[0]),
+      float(g.friction[1]),
+      float(g.friction[2]),
+    ),
+    margin=float(g.margin),
+    gap=float(g.gap),
+    solref=(float(g.solref[0]), float(g.solref[1])),
+    solimp=(
+      float(g.solimp[0]),
+      float(g.solimp[1]),
+      float(g.solimp[2]),
+      float(g.solimp[3]),
+      float(g.solimp[4]),
+    ),
+    mass=float(g.mass),
+    density=float(g.density),
+  )
+
+
+def _compute_slot_metadata(
+  variant_names: tuple[str, ...],
+  variant_specs: list[mujoco.MjSpec],
+) -> tuple[
+  tuple[VariantSlot, ...],
+  tuple[tuple[VariantGeomSpec | None, ...], ...],
+]:
+  """Compute slot list and per-variant slot specs.
+
+  Walks each variant's body tree, buckets mesh geoms by ``(body_path,
+  role)``, and assigns ordinals deterministically from source order.
+  Slot count per ``(body_path, role)`` equals the max across variants;
+  variants with fewer geoms in that bucket leave trailing slots
+  unfilled (``None`` in ``variant_slot_specs``).
+  """
+  mesh_type = int(mujoco.mjtGeom.mjGEOM_MESH)
+
+  # Per-variant {body_path -> {role -> [VariantGeomSpec]}}.
+  per_variant_buckets: list[dict[str, dict[GeomRole, list[VariantGeomSpec]]]] = []
+  for spec in variant_specs:
+    root = list(spec.worldbody.bodies)[0]
+    buckets: dict[str, dict[GeomRole, list[VariantGeomSpec]]] = {}
+    for path, body in _iter_body_paths(root):
+      role_buckets = buckets.setdefault(path, {"visual": [], "collision": []})
+      for g in body.geoms:
+        if int(g.type) != mesh_type:
+          continue
+        role_buckets[_classify_geom_role(g)].append(_extract_variant_geom_spec(g))
+    per_variant_buckets.append(buckets)
+
+  # All body paths present in any variant. (Validation ensures the path
+  # sets agree across variants, but use the union here for safety.)
+  all_paths: set[str] = set()
+  for buckets in per_variant_buckets:
+    all_paths.update(buckets.keys())
+
+  slots: list[VariantSlot] = []
+  per_variant_slot_specs: list[list[VariantGeomSpec | None]] = [
+    [] for _ in variant_names
+  ]
+
+  # Deterministic order: sort body paths lexicographically, then visual
+  # before collision per body, then by ordinal.
+  for body_path in sorted(all_paths):
+    for role in ("visual", "collision"):
+      max_count = 0
+      for buckets in per_variant_buckets:
+        count = len(buckets.get(body_path, {}).get(role, []))
+        if count > max_count:
+          max_count = count
+      for ordinal in range(max_count):
+        source_names: list[str | None] = []
+        slot_specs: list[VariantGeomSpec | None] = []
+        for variant_buckets in per_variant_buckets:
+          variant_geoms = variant_buckets.get(body_path, {}).get(role, [])
+          if ordinal < len(variant_geoms):
+            geom_spec = variant_geoms[ordinal]
+            source_names.append(geom_spec.geom_name)
+            slot_specs.append(geom_spec)
+          else:
+            source_names.append(None)
+            slot_specs.append(None)
+        template_name = f"mjlab/pad{body_path}/{role}/{ordinal}"
+        slots.append(
+          VariantSlot(
+            key=SlotKey(
+              body_path=body_path,
+              role=role,
+              ordinal=ordinal,
+            ),
+            template_geom_name=template_name,
+            source_geom_names=tuple(source_names),
+          )
+        )
+        for variant_idx, slot_spec in enumerate(slot_specs):
+          per_variant_slot_specs[variant_idx].append(slot_spec)
+
+  return tuple(slots), tuple(tuple(s) for s in per_variant_slot_specs)
+
+
+##
+# Build pipeline (entity-time): merge variant specs into one padded template.
+##
+
+
+def build_merged_variant_spec(
+  cfg: VariantEntityCfg,
+) -> tuple[mujoco.MjSpec, VariantMetadata]:
+  """Merge a ``VariantEntityCfg``'s variants into a single padded template.
+
+  Validates that all variants share the same kinematic structure, merges
+  every variant's mesh assets into the template namespace, slot-renames
+  variant 0's mesh geoms to ``mjlab/pad/<body>/<role>/<ordinal>``, and
+  synthesizes padding geoms (per-(body, role)) for slots that variant 0
+  does not fill, so the template's geom count and bodyid layout cover
+  every variant's needs.
+
+  Returns the merged template spec and a ``VariantMetadata`` describing
+  the slot layout, per-variant slot specs, and explicit body inertials.
+  The reference compile in :func:`build_variant_model` overrides every
+  per-variant attribute via ``VariantGeomSpec``, so variant 0 being "the
+  template" does not privilege its attributes.
+  """
+  variants = cfg.variants
+  if not variants:
+    raise ValueError("VariantEntityCfg.variants must contain at least one entry.")
+
+  variant_names: list[str] = []
+  variant_specs: list[mujoco.MjSpec] = []
+  for name, spec_fn in variants.items():
+    variant_names.append(name)
+    variant_specs.append(spec_fn())
+
+  # Resolve cfg.assignment (None | dict | callable) into the metadata's
+  # unified ``assignment`` field. None and dict both produce a weights
+  # tuple keyed by variant declaration order; a callable passes through.
+  resolved_assignment: tuple[float, ...] | Callable[[int], Sequence[int]]
+  cfg_assignment = cfg.assignment
+  if cfg_assignment is None:
+    resolved_assignment = (1.0,) * len(variant_names)
+  elif isinstance(cfg_assignment, dict):
+    weights_dict = cast(dict[str, float], cfg_assignment)
+    resolved_assignment = tuple(weights_dict.get(n, 1.0) for n in variant_names)
+  else:
+    resolved_assignment = cfg_assignment
+
+  # Validate cross-variant topology (recursive body tree, joints,
+  # primitive geoms, actuators, sensors, tendons, equalities, inertial
+  # mode consistency, and reserved-prefix collisions). The validator
+  # enforces "exactly one root body under worldbody" itself.
+  validate_variant_specs(variant_names, variant_specs)
+
+  variant_bodies: list[mujoco.MjsBody] = [
+    list(spec.worldbody.bodies)[0] for spec in variant_specs
+  ]
+
+  # Variant entities must be floating-base. Mocap auto-wrap is not applied
+  # for variant entities, so fixed-base variants would silently stack at
+  # the world origin. Variants share joint structure (validated above), so
+  # checking the first is sufficient.
+  ref_joints = list(variant_bodies[0].joints)
+  if not ref_joints or ref_joints[0].type != mujoco.mjtJoint.mjJNT_FREE:
+    raise ValueError(
+      "VariantEntityCfg requires floating-base variants. Each variant's "
+      "root body must declare a free joint via body.add_freejoint(); "
+      "fixed-base variants are not supported."
+    )
+
+  # Compute slot-based metadata from source specs BEFORE any mesh
+  # renaming or merging. This captures (body_path, role, ordinal) keyed
+  # slots and per-variant geom attributes for the slot-aware build path.
+  slots, variant_slot_specs = _compute_slot_metadata(
+    tuple(variant_names), variant_specs
+  )
+
+  # Snapshot a clean copy of every source spec BEFORE the merge mutates
+  # variant 0's spec (mesh renames, slot-name geom renames, padding geom
+  # synthesis). The sim-time build compiles each of these in isolation
+  # to populate per-world fields, avoiding the O(N) cost of recompiling
+  # the merged scene per unique variant assignment.
+  variant_source_specs = tuple(s.copy() for s in variant_specs)
+
+  # Use variant 0's spec as the template. The merge:
+  #   1. prefixes variant 0's mesh names with its variant name and
+  #      copies every other variant's mesh assets into the template;
+  #   2. renames variant 0's mesh geoms to slot template names so
+  #      every mesh geom in the merged template is addressable by
+  #      ``slot.template_geom_name``;
+  #   3. synthesizes padding geoms (per-(body, role)) for slots that
+  #      variant 0 does not fill, so the template's geom count and
+  #      bodyid layout cover every variant's needs.
+  template_spec = variant_specs[0]
+  template_body = variant_bodies[0]
+
+  # (1) Rename template meshes and update mesh references on the
+  # template body's geoms (recursive: child bodies may also reference
+  # the template variant's meshes).
+  template_prefix = f"{variant_names[0]}/"
+  old_to_new: dict[str, str] = {}
+  for mesh in template_spec.meshes:
+    new_name = f"{template_prefix}{mesh.name}"
+    old_to_new[mesh.name] = new_name
+    mesh.name = new_name
+  for _, body in _iter_body_paths(template_body):
+    for g in body.geoms:
+      if g.meshname in old_to_new:
+        g.meshname = old_to_new[g.meshname]
+
+  # Copy mesh assets from other variants into the template namespace.
+  for i in range(1, len(variant_specs)):
+    prefix = f"{variant_names[i]}/"
+    for mesh in variant_specs[i].meshes:
+      new_mesh = template_spec.add_mesh()
+      new_mesh.name = f"{prefix}{mesh.name}"
+      copy_mesh_data(mesh, new_mesh)
+
+  # Mirror of the mesh treatment above for textures and materials.
+  texture_old_to_new: dict[str, str] = {}
+  for tex in template_spec.textures:
+    new_name = f"{template_prefix}{tex.name}"
+    texture_old_to_new[tex.name] = new_name
+    tex.name = new_name
+  material_old_to_new: dict[str, str] = {}
+  for mat in template_spec.materials:
+    new_name = f"{template_prefix}{mat.name}"
+    material_old_to_new[mat.name] = new_name
+    mat.name = new_name
+    mat.textures = [texture_old_to_new.get(t, t) for t in mat.textures]
+  for _, body in _iter_body_paths(template_body):
+    for g in body.geoms:
+      if g.material in material_old_to_new:
+        g.material = material_old_to_new[g.material]
+
+  # Copy texture/material assets from other variants into the template.
+  for i in range(1, len(variant_specs)):
+    prefix = f"{variant_names[i]}/"
+    src_to_dst_tex: dict[str, str] = {}
+    for tex in variant_specs[i].textures:
+      new_tex = template_spec.add_texture()
+      new_tex.name = f"{prefix}{tex.name}"
+      src_to_dst_tex[tex.name] = new_tex.name
+      copy_texture_data(tex, new_tex)
+    for mat in variant_specs[i].materials:
+      new_mat = template_spec.add_material()
+      new_mat.name = f"{prefix}{mat.name}"
+      copy_material_data(mat, new_mat)
+      new_mat.textures = [src_to_dst_tex.get(t, t) for t in new_mat.textures]
+
+  # (2) Slot-driven rename of variant 0's existing mesh geoms. Walk
+  # the template body tree; within each (body, role) bucket, the
+  # n-th mesh geom (in source order) maps to slot ordinal n.
+  mesh_type = mujoco.mjtGeom.mjGEOM_MESH
+  slot_by_key: dict[SlotKey, VariantSlot] = {s.key: s for s in slots}
+  template_bodies_by_path: dict[str, mujoco.MjsBody] = {}
+  filled_template_slot_keys: set[SlotKey] = set()
+  for body_path, body in _iter_body_paths(template_body):
+    template_bodies_by_path[body_path] = body
+    role_ordinals: dict[GeomRole, int] = {"visual": 0, "collision": 0}
+    for g in body.geoms:
+      if g.type != mesh_type:
+        continue
+      role = _classify_geom_role(g)
+      ordinal = role_ordinals[role]
+      role_ordinals[role] += 1
+      key = SlotKey(body_path=body_path, role=role, ordinal=ordinal)
+      slot = slot_by_key[key]
+      g.name = slot.template_geom_name
+      filled_template_slot_keys.add(key)
+
+  # (3) Synthesize per-(body, role) padding geoms for slots variant 0
+  # doesn't fill. Each padding geom uses the slot's reserved
+  # ``mjlab/pad/...`` template name, the role's union contact bits,
+  # and a placeholder mesh from the lowest-index variant that fills
+  # the slot. ``mass=0`` and ``density=0`` keep the placeholder from
+  # contributing to the template's body inertial inference; the
+  # per-variant reference compile handles further masking.
+  for s_idx, slot in enumerate(slots):
+    if slot.key in filled_template_slot_keys:
+      continue
+    target_body = template_bodies_by_path[slot.key.body_path]
+    pad_geom = target_body.add_geom()
+    pad_geom.type = mesh_type
+    pad_geom.name = slot.template_geom_name
+    if slot.key.role == "visual":
+      pad_geom.contype = 0
+      pad_geom.conaffinity = 0
+    else:
+      pad_geom.contype = 1
+      pad_geom.conaffinity = 1
+    placeholder_set = False
+    for v_idx, slot_specs in enumerate(variant_slot_specs):
+      gs = slot_specs[s_idx]
+      if gs is None:
+        continue
+      pad_geom.meshname = f"{variant_names[v_idx]}/{gs.mesh_name}"
+      placeholder_set = True
+      break
+    assert placeholder_set, (
+      f"slot {slot.key} has no filling variant; "
+      "_compute_slot_metadata must not emit unfilled slots."
+    )
+    pad_geom.mass = 0.0
+    pad_geom.density = 0.0
+
+  metadata = VariantMetadata(
+    variant_names=tuple(variant_names),
+    assignment=resolved_assignment,
+    slots=slots,
+    variant_slot_specs=variant_slot_specs,
+    variant_source_specs=variant_source_specs,
+  )
+  return template_spec, metadata
+
+
+##
+# Build pipeline (sim-time): produce a heterogeneous Warp model.
+#
+# The module-level entry point is ``build_variant_model`` at the bottom
+# of this section. ``allocate_worlds`` is its world-assignment step and
+# is also exposed for unit testing the largest-remainder math in
+# isolation. Everything between is private to ``build_variant_model``
+# (or to ``_populate_dependent_fields``, which is itself private).
+##
+
+
+def _qualified_mesh_name(entity_prefix: str, variant_name: str, mesh_name: str) -> str:
+  """Mesh asset name in the merged template's namespace.
+
+  Source mesh names are prefixed with the variant name during merge
+  (``<variant>/<mesh>``); after scene attach the entity prefix is
+  added (``<entity>/<variant>/<mesh>``).
+  """
+  return f"{entity_prefix}{variant_name}/{mesh_name}"
+
+
+def _qualified_material_name(
+  entity_prefix: str, variant_name: str, material_name: str
+) -> str:
+  """Material asset name in the merged template's namespace.
+
+  Source materials are prefixed with the variant name during merge
+  (``<variant>/<material>``); after scene attach the entity prefix is
+  added (``<entity>/<variant>/<material>``).
+  """
+  return f"{entity_prefix}{variant_name}/{material_name}"
+
+
+def _qualified_slot_geom_name(entity_prefix: str, template_geom_name: str) -> str:
+  """Slot geom name in the merged template's namespace after attach."""
+  return f"{entity_prefix}{template_geom_name}"
+
+
+def _populate_dependent_fields(
+  m: mjwarp.Model,
+  padded_model: mujoco.MjModel,
+  nworld: int,
+  variant_info: list[tuple[str, VariantMetadata]],
+  world_to_variant: dict[str, np.ndarray],
+) -> None:
+  """Populate per-world Warp arrays for the geometry-dependent fields.
+
+  Compiles each variant's *source* spec in isolation (small, single-entity
+  spec) and scatters per-body and per-geom fields into per-world arrays.
+  Total cost is the sum of per-source compiles across all variant
+  entities, i.e. linear in the number of variants. This avoids the
+  O(N^2) cost of recompiling the merged scene per unique variant
+  assignment.
+
+  For non-variant bodies and non-slot geoms, values come from a single
+  base scene compile (``padded_model``) broadcast across worlds. For
+  variant entity bodies and slot geoms, the per-world value comes from
+  the corresponding variant's source compile. ``body_subtreemass`` for
+  ancestors of each variant entity's root body is updated per-world by
+  applying the per-variant subtreemass delta.
+  """
+  ngeom = padded_model.ngeom
+  nbody = padded_model.nbody
+
+  # Initialize per-world arrays from the base scene compile. Bodies and
+  # geoms not touched by any variant entity inherit these values. We
+  # broadcast then copy so writes to per-world rows don't alias.
+  def _broadcast(src: np.ndarray, shape: tuple[int, ...]) -> np.ndarray:
+    return np.broadcast_to(src.astype(np.float32), shape).copy()
+
+  geom_size = _broadcast(padded_model.geom_size, (nworld, ngeom, 3))
+  geom_rbound = _broadcast(padded_model.geom_rbound, (nworld, ngeom))
+  geom_aabb = _broadcast(
+    padded_model.geom_aabb.reshape(ngeom, 2, 3), (nworld, ngeom, 2, 3)
+  )
+  geom_pos = _broadcast(padded_model.geom_pos, (nworld, ngeom, 3))
+  geom_quat = _broadcast(padded_model.geom_quat, (nworld, ngeom, 4))
+  body_mass = _broadcast(padded_model.body_mass, (nworld, nbody))
+  body_subtreemass = _broadcast(padded_model.body_subtreemass, (nworld, nbody))
+  body_inertia = _broadcast(padded_model.body_inertia, (nworld, nbody, 3))
+  body_invweight0 = _broadcast(padded_model.body_invweight0, (nworld, nbody, 2))
+  body_ipos = _broadcast(padded_model.body_ipos, (nworld, nbody, 3))
+  body_iquat = _broadcast(padded_model.body_iquat, (nworld, nbody, 4))
+
+  mesh_type = mujoco.mjtGeom.mjGEOM_MESH
+
+  for entity_prefix, metadata in variant_info:
+    w2v = world_to_variant[entity_prefix]
+
+    # Use any variant's source spec to enumerate body paths and the
+    # entity's slot geom names. Validation guarantees variants share
+    # the same body tree and slot keys, so the choice is arbitrary.
+    sample_spec = metadata.variant_source_specs[0]
+    sample_root = list(sample_spec.worldbody.bodies)[0]
+
+    # Map each variant-entity body path to its scene body id. Body
+    # names in the scene are the bare body name prefixed by the
+    # entity's attach prefix.
+    scene_body_id_by_path: dict[str, int] = {}
+    body_name_by_path: dict[str, str] = {}
+    for body_path, body in _iter_body_paths(sample_root):
+      body_name_by_path[body_path] = body.name or ""
+      scene_name = f"{entity_prefix}{body.name or ''}"
+      bid = mujoco.mj_name2id(padded_model, mujoco.mjtObj.mjOBJ_BODY, scene_name)
+      if bid < 0:
+        raise ValueError(
+          f"variant entity body '{scene_name}' not found in compiled scene."
+        )
+      scene_body_id_by_path[body_path] = bid
+
+    # Map each slot key to its scene geom id.
+    scene_geom_id_by_slot: dict[SlotKey, int] = {}
+    for slot in metadata.slots:
+      full_geom_name = _qualified_slot_geom_name(entity_prefix, slot.template_geom_name)
+      gid = mujoco.mj_name2id(padded_model, mujoco.mjtObj.mjOBJ_GEOM, full_geom_name)
+      if gid < 0:
+        raise ValueError(
+          f"slot geom '{full_geom_name}' (entity '{entity_prefix}') not "
+          f"found in compiled scene."
+        )
+      scene_geom_id_by_slot[slot.key] = gid
+
+    # Variant entity's root body (shortest body path), used to compute
+    # the subtreemass delta to propagate to ancestors. The root path is
+    # always the lex-smallest among the entity's body paths (parents
+    # sort before children).
+    sorted_paths = sorted(scene_body_id_by_path.keys())
+    root_body_path = sorted_paths[0]
+    root_scene_bid = scene_body_id_by_path[root_body_path]
+
+    # Walk up the scene's parent chain from the variant root to
+    # worldbody (inclusive). The variant root's own subtreemass is
+    # written from the per-variant compile; each ancestor receives an
+    # additive delta equal to (variant_subtreemass - base_subtreemass).
+    ancestor_ids: list[int] = []
+    parent_id = int(padded_model.body_parentid[root_scene_bid])
+    while True:
+      ancestor_ids.append(parent_id)
+      if parent_id == 0:
+        break
+      parent_id = int(padded_model.body_parentid[parent_id])
+    base_root_subtreemass = float(padded_model.body_subtreemass[root_scene_bid])
+
+    # Compile each variant's source spec in isolation and scatter values
+    # into the per-world arrays for the worlds assigned to that variant.
+    for v_idx in range(len(metadata.variant_names)):
+      worlds = np.where(w2v == v_idx)[0]
+      if worlds.size == 0:
+        continue
+
+      source_spec = metadata.variant_source_specs[v_idx].copy()
+      v_model = source_spec.compile()
+
+      source_root = list(source_spec.worldbody.bodies)[0]
+      source_body_id_by_path: dict[str, int] = {}
+      for body_path, body in _iter_body_paths(source_root):
+        source_body_id_by_path[body_path] = body.id
+
+      # Scatter per-body fields for every body in the variant entity's
+      # subtree. Bodies without explicit inertials inherit the
+      # mesh-derived inertia from the variant's mesh assignment in the
+      # source compile, which is exactly what we want.
+      for body_path, scene_bid in scene_body_id_by_path.items():
+        source_bid = source_body_id_by_path[body_path]
+        body_mass[worlds, scene_bid] = v_model.body_mass[source_bid]
+        body_subtreemass[worlds, scene_bid] = v_model.body_subtreemass[source_bid]
+        body_inertia[worlds, scene_bid] = v_model.body_inertia[source_bid]
+        body_invweight0[worlds, scene_bid] = v_model.body_invweight0[source_bid]
+        body_ipos[worlds, scene_bid] = v_model.body_ipos[source_bid]
+        body_iquat[worlds, scene_bid] = v_model.body_iquat[source_bid]
+
+      # Scatter per-geom fields for each slot this variant fills. Map
+      # each (body_path, role, ordinal) slot to the corresponding geom
+      # in the source compile by re-walking the source body tree (same
+      # ordering rules as ``_compute_slot_metadata``).
+      for body_path, body in _iter_body_paths(source_root):
+        role_ordinals: dict[GeomRole, int] = {"visual": 0, "collision": 0}
+        for g in body.geoms:
+          if g.type != mesh_type:
+            continue
+          role = _classify_geom_role(g)
+          ordinal = role_ordinals[role]
+          role_ordinals[role] += 1
+          slot_key = SlotKey(body_path=body_path, role=role, ordinal=ordinal)
+          scene_gid = scene_geom_id_by_slot.get(slot_key)
+          if scene_gid is None:
+            continue
+          source_gid = g.id
+          geom_size[worlds, scene_gid] = v_model.geom_size[source_gid]
+          geom_rbound[worlds, scene_gid] = v_model.geom_rbound[source_gid]
+          geom_aabb[worlds, scene_gid] = v_model.geom_aabb[source_gid].reshape(2, 3)
+          geom_pos[worlds, scene_gid] = v_model.geom_pos[source_gid]
+          geom_quat[worlds, scene_gid] = v_model.geom_quat[source_gid]
+
+      # Propagate the variant root's subtreemass delta up the ancestor
+      # chain. Base ancestor subtreemass already includes the placeholder
+      # contribution from the merged scene compile; adding the delta
+      # swaps that placeholder contribution for the variant's actual
+      # contribution.
+      delta = (
+        float(v_model.body_subtreemass[source_body_id_by_path[root_body_path]])
+        - base_root_subtreemass
+      )
+      for anc_bid in ancestor_ids:
+        body_subtreemass[worlds, anc_bid] += delta
+
+  m.geom_size = wp.array(geom_size, dtype=wp.vec3)
+  m.geom_rbound = wp.array(geom_rbound, dtype=float)
+  m.geom_aabb = wp.array(geom_aabb, dtype=wp.vec3)
+  m.geom_pos = wp.array(geom_pos, dtype=wp.vec3)
+  m.geom_quat = wp.array(geom_quat, dtype=wp.quat)
+  m.body_mass = wp.array(body_mass, dtype=float)
+  m.body_subtreemass = wp.array(body_subtreemass, dtype=float)
+  m.body_inertia = wp.array(body_inertia, dtype=wp.vec3)
+  m.body_invweight0 = wp.array(body_invweight0, dtype=wp.vec2)
+  m.body_ipos = wp.array(body_ipos, dtype=wp.vec3)
+  m.body_iquat = wp.array(body_iquat, dtype=wp.quat)
+
+
+def allocate_worlds(
+  weights: tuple[float, ...],
+  nworld: int,
+) -> list[int]:
+  """Assign worlds proportionally by weight (largest-remainder method).
+
+  Returns a list of length *nworld* containing variant indices. Weights
+  must be non-negative with at least one positive entry.
+  """
+  if any(w < 0 for w in weights):
+    raise ValueError(f"weights must be non-negative, got {weights}.")
+  total = sum(weights)
+  if total <= 0:
+    raise ValueError(f"weights must have a positive sum, got {weights}.")
+  quotas = [(w / total) * nworld for w in weights]
+  floors = [int(q) for q in quotas]
+  remainders = sorted(
+    ((quotas[i] - floors[i], i) for i in range(len(weights))),
+    key=lambda x: -x[0],
+  )
+  allocated = sum(floors)
+  for j in range(nworld - allocated):
+    floors[remainders[j][1]] += 1
+  assignment: list[int] = []
+  for idx, count in enumerate(floors):
+    assignment.extend([idx] * count)
+  return assignment
+
+
+def build_variant_model(
+  spec: mujoco.MjSpec,
+  nworld: int,
+  variant_info: list[tuple[str, VariantMetadata]],
+  configure_model: Callable[[mujoco.MjModel], None] | None = None,
+) -> MeshVariantResult:
+  """Build a Warp Model with per-world mesh assignments.
+
+  Args:
+    spec: Scene spec (already merged with padded variant geoms).
+    nworld: Number of simulation worlds.
+    variant_info: List of ``(entity_prefix, metadata)`` pairs for
+      entities that have mesh variants.
+    configure_model: Optional callback to configure the compiled
+      MjModel before ``put_model`` (e.g., setting solver options).
+
+  Returns:
+    A :class:`MeshVariantResult` containing the warp model, host
+    model, and per-entity world-to-variant mappings.
+  """
+  spec = spec.copy()
+  model = spec.compile()
+  if configure_model is not None:
+    configure_model(model)
+
+  # Start from base dataid tiled for all worlds.
+  base_dataid = model.geom_dataid.copy()
+  dataid_table = np.tile(base_dataid, (nworld, 1))
+
+  # Same treatment for matid so each variant can use its own material.
+  base_matid = model.geom_matid.copy()
+  matid_table = np.tile(base_matid, (nworld, 1))
+
+  world_to_variant: dict[str, np.ndarray] = {}
+
+  for entity_prefix, metadata in variant_info:
+    slots = metadata.slots
+    nslots = len(slots)
+    nvariants = len(metadata.variant_names)
+
+    # Resolve world-to-variant assignment. The metadata's ``assignment``
+    # is either a tuple of weights (from None or dict on the cfg) or a
+    # callable. Use ``callable()`` for the dispatch since tuples are
+    # not callable.
+    assignment_spec = metadata.assignment
+    if callable(assignment_spec):
+      assignment = list(assignment_spec(nworld))
+      if len(assignment) != nworld:
+        raise ValueError(
+          f"VariantEntityCfg.assignment (entity '{entity_prefix}') "
+          f"returned {len(assignment)} indices but nworld={nworld}."
+        )
+      for w, v in enumerate(assignment):
+        if not (0 <= int(v) < nvariants):
+          raise ValueError(
+            f"VariantEntityCfg.assignment (entity '{entity_prefix}') "
+            f"returned variant index {v} at world {w}, but only "
+            f"{nvariants} variants are declared."
+          )
+    else:
+      assignment = allocate_worlds(assignment_spec, nworld)
+    w2v = np.array(assignment, dtype=np.int32)
+    world_to_variant[entity_prefix] = w2v
+
+    # Resolve slot geom IDs by template name (deterministic, no
+    # positional or unnamed-padding heuristics).
+    slot_geom_ids = np.zeros(nslots, dtype=np.int64)
+    for s_idx, slot in enumerate(slots):
+      full_geom_name = _qualified_slot_geom_name(entity_prefix, slot.template_geom_name)
+      gid = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_GEOM, full_geom_name)
+      if gid < 0:
+        raise ValueError(
+          f"Slot geom '{full_geom_name}' (entity '{entity_prefix}', "
+          f"slot {slot.key}) not found in compiled model."
+        )
+      slot_geom_ids[s_idx] = gid
+
+    # Resolve every (variant, slot) -> (mesh_id, mat_id). ``-1`` denotes
+    # an unfilled slot (mesh) or a slot rendered without a material
+    # (matid).
+    variant_slot_mesh_ids = np.full((nvariants, nslots), -1, dtype=np.int64)
+    variant_slot_matids = np.full((nvariants, nslots), -1, dtype=np.int64)
+    for v_idx, slot_specs in enumerate(metadata.variant_slot_specs):
+      variant_name = metadata.variant_names[v_idx]
+      for s_idx, gspec in enumerate(slot_specs):
+        if gspec is None:
+          continue
+        full_mesh_name = _qualified_mesh_name(
+          entity_prefix, variant_name, gspec.mesh_name
+        )
+        mid = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_MESH, full_mesh_name)
+        if mid < 0:
+          raise ValueError(
+            f"Mesh '{full_mesh_name}' (variant '{variant_name}', "
+            f"slot {slots[s_idx].key}) not found in compiled model."
+          )
+        variant_slot_mesh_ids[v_idx, s_idx] = mid
+        if gspec.material:
+          full_mat_name = _qualified_material_name(
+            entity_prefix, variant_name, gspec.material
+          )
+          matid = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_MATERIAL, full_mat_name)
+          if matid < 0:
+            raise ValueError(
+              f"Material '{full_mat_name}' (variant '{variant_name}', "
+              f"slot {slots[s_idx].key}) not found in compiled model."
+            )
+          variant_slot_matids[v_idx, s_idx] = matid
+
+    # Vectorized scatter: per-world row from variant assignment.
+    dataid_table[:, slot_geom_ids] = variant_slot_mesh_ids[w2v]
+    matid_table[:, slot_geom_ids] = variant_slot_matids[w2v]
+
+  # Build warp model.
+  m = mjwarp.put_model(model)
+  m.geom_dataid = wp.array(dataid_table, dtype=int)
+  m.geom_matid = wp.array(matid_table, dtype=int)
+
+  # Populate dependent per-world fields.
+  _populate_dependent_fields(m, model, nworld, variant_info, world_to_variant)
+
+  return MeshVariantResult(
+    wp_model=m,
+    mj_model=model,
+    world_to_variant=world_to_variant,
+  )
diff --git a/src/mjlab/envs/__init__.py b/src/mjlab/envs/__init__.py
new file mode 100644
index 0000000..f56adab
--- /dev/null
+++ b/src/mjlab/envs/__init__.py
@@ -0,0 +1,4 @@
+from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv as ManagerBasedRlEnv
+from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnvCfg as ManagerBasedRlEnvCfg
+from mjlab.envs.types import VecEnvObs as VecEnvObs
+from mjlab.envs.types import VecEnvStepReturn as VecEnvStepReturn
diff --git a/src/mjlab/envs/manager_based_rl_env.py b/src/mjlab/envs/manager_based_rl_env.py
new file mode 100644
index 0000000..6665930
--- /dev/null
+++ b/src/mjlab/envs/manager_based_rl_env.py
@@ -0,0 +1,618 @@
+import math
+from dataclasses import dataclass, field
+from typing import Any
+
+import mujoco
+import numpy as np
+import torch
+import warp as wp
+from prettytable import PrettyTable
+
+from mjlab.envs import types
+from mjlab.envs.mdp.events import reset_scene_to_default
+from mjlab.managers.action_manager import ActionManager, ActionTermCfg
+from mjlab.managers.command_manager import (
+  CommandManager,
+  CommandTermCfg,
+  NullCommandManager,
+)
+from mjlab.managers.curriculum_manager import (
+  CurriculumManager,
+  CurriculumTermCfg,
+  NullCurriculumManager,
+)
+from mjlab.managers.event_manager import EventManager, EventTermCfg
+from mjlab.managers.metrics_manager import (
+  MetricsManager,
+  MetricsTermCfg,
+  NullMetricsManager,
+)
+from mjlab.managers.observation_manager import ObservationGroupCfg, ObservationManager
+from mjlab.managers.recorder_manager import (
+  NullRecorderManager,
+  RecorderManager,
+  RecorderTermCfg,
+)
+from mjlab.managers.reward_manager import RewardManager, RewardTermCfg
+from mjlab.managers.termination_manager import TerminationManager, TerminationTermCfg
+from mjlab.scene import Scene
+from mjlab.scene.scene import SceneCfg
+from mjlab.sim import SimulationCfg
+from mjlab.sim.sim import Simulation
+from mjlab.utils import random as random_utils
+from mjlab.utils.logging import print_info
+from mjlab.utils.spaces import Box
+from mjlab.utils.spaces import Dict as DictSpace
+from mjlab.viewer.debug_visualizer import DebugVisualizer
+from mjlab.viewer.offscreen_renderer import OffscreenRenderer
+from mjlab.viewer.viewer_config import ViewerConfig
+
+
+@dataclass(kw_only=True)
+class ManagerBasedRlEnvCfg:
+  """Configuration for a manager-based RL environment.
+
+  This config defines all aspects of an RL environment: the physical scene,
+  observations, actions, rewards, terminations, and optional features like
+  commands and curriculum learning.
+
+  The environment step size is ``sim.mujoco.timestep * decimation``. For example,
+  with a 2ms physics timestep and decimation=10, the environment runs at 50Hz.
+  """
+
+  # Base environment configuration.
+
+  decimation: int
+  """Number of physics simulation steps per environment step. Higher values mean
+  coarser control frequency. Environment step duration = physics_dt * decimation."""
+
+  scene: SceneCfg
+  """Scene configuration defining terrain, entities, and sensors. The scene
+  specifies ``num_envs``, the number of parallel environments."""
+
+  observations: dict[str, ObservationGroupCfg] = field(default_factory=dict)
+  """Observation groups configuration. Each group (e.g., "actor", "critic") contains
+  observation terms that are concatenated. Groups can have different settings for
+  noise, history, and delay."""
+
+  actions: dict[str, ActionTermCfg] = field(default_factory=dict)
+  """Action terms configuration. Each term controls a specific entity/aspect
+  (e.g., joint positions). Action dimensions are concatenated across terms."""
+
+  events: dict[str, EventTermCfg] = field(
+    default_factory=lambda: {
+      "reset_scene_to_default": EventTermCfg(
+        func=reset_scene_to_default,
+        mode="reset",
+      )
+    }
+  )
+  """Event terms for domain randomization and state resets. Default includes
+  ``reset_scene_to_default`` which resets entities to their initial state.
+  Can be set to empty to disable all events including default reset."""
+
+  seed: int | None = None
+  """Random seed for reproducibility. If None, a random seed is used. The actual
+  seed used is stored back into this field after initialization."""
+
+  sim: SimulationCfg = field(default_factory=SimulationCfg)
+  """Simulation configuration including physics timestep, solver iterations,
+  contact parameters, and NaN guarding."""
+
+  viewer: ViewerConfig = field(default_factory=ViewerConfig)
+  """Viewer configuration for rendering (camera position, resolution, etc.)."""
+
+  # RL-specific configuration.
+
+  episode_length_s: float = 0.0
+  """Duration of an episode (in seconds).
+
+  Episode length in steps is computed as:
+    ceil(episode_length_s / (sim.mujoco.timestep * decimation))
+  """
+
+  rewards: dict[str, RewardTermCfg] = field(default_factory=dict)
+  """Reward terms configuration."""
+
+  terminations: dict[str, TerminationTermCfg] = field(default_factory=dict)
+  """Termination terms configuration. If empty, episodes never reset. Use
+  ``mdp.time_out`` with ``time_out=True`` for episode time limits."""
+
+  commands: dict[str, CommandTermCfg] = field(default_factory=dict)
+  """Command generator terms (e.g., velocity targets)."""
+
+  curriculum: dict[str, CurriculumTermCfg] = field(default_factory=dict)
+  """Curriculum terms for adaptive difficulty."""
+
+  metrics: dict[str, MetricsTermCfg] = field(default_factory=dict)
+  """Custom metric terms for logging per-step values as episode averages."""
+
+  recorders: dict[str, RecorderTermCfg] = field(default_factory=dict)
+  """Recorder terms for logging observations, actions, or other data during rollouts.
+  If empty, a no-op manager is used with zero overhead."""
+
+  is_finite_horizon: bool = False
+  """Whether the task has a finite or infinite horizon. Defaults to False (infinite).
+
+  - **Finite horizon (True)**: The time limit defines the task boundary. When reached,
+    no future value exists beyond it, so the agent receives a terminal done signal.
+  - **Infinite horizon (False)**: The time limit is an artificial cutoff. The agent
+    receives a truncated done signal to bootstrap the value of continuing beyond the
+    limit.
+  """
+
+  auto_reset: bool = True
+  """Whether to automatically reset environments that terminate or time out.
+
+  When True (default), ``step()`` resets done environments and returns post-reset
+  observations. When False, ``step()`` returns the true terminal observation and the
+  caller must explicitly call ``reset(env_ids=...)`` for done environments before the
+  next ``step()``.
+
+  Note: mjlab's bundled ``train.py`` goes through rsl_rl's ``OnPolicyRunner``, which
+  does not drive manual resets. ``auto_reset=False`` is intended for users running
+  their own training loop (or a wrapper that handles the reset between steps).
+  """
+
+  scale_rewards_by_dt: bool = True
+  """Whether to multiply rewards by the environment step duration (dt).
+
+  When True (default), reward values are scaled by step_dt to normalize cumulative
+  episodic rewards across different simulation frequencies. Set to False for
+  algorithms that expect unscaled reward signals (e.g., HER, static reward scaling).
+  """
+
+
+class ManagerBasedRlEnv:
+  """Manager-based RL environment."""
+
+  is_vector_env = True
+  metadata = {
+    "render_modes": [None, "rgb_array"],
+    "mujoco_version": mujoco.__version__,
+    "warp_version": wp.config.version,
+  }
+  cfg: ManagerBasedRlEnvCfg
+
+  def __init__(
+    self,
+    cfg: ManagerBasedRlEnvCfg,
+    device: str,
+    render_mode: str | None = None,
+    **kwargs,
+  ) -> None:
+    # Initialize base environment state.
+    self.cfg = cfg
+    if self.cfg.seed is not None:
+      self.cfg.seed = self.seed(self.cfg.seed)
+    self._sim_step_counter = 0
+    self.extras = {}
+    self.obs_buf = {}
+    self._manual_reset_pending = torch.zeros(
+      self.cfg.scene.num_envs, dtype=torch.bool, device=device
+    )
+    # Scratch buffer for per-env command dt; see step().
+    self._command_dt = torch.zeros(self.cfg.scene.num_envs, device=device)
+
+    # Initialize scene and simulation.
+    self.scene = Scene(self.cfg.scene, device=device)
+    self.sim = Simulation(
+      num_envs=self.scene.num_envs,
+      cfg=self.cfg.sim,
+      spec=self.scene.spec,
+      variant_info=self.scene.collect_variant_info(),
+      device=device,
+    )
+
+    self.scene.initialize(
+      mj_model=self.sim.mj_model,
+      model=self.sim.model,
+      data=self.sim.data,
+    )
+
+    # Wire sensor context to simulation for sense_graph.
+    if self.scene.sensor_context is not None:
+      self.sim.set_sensor_context(self.scene.sensor_context)
+
+    # Print environment info.
+    print_info("")
+    table = PrettyTable()
+    table.title = "Base Environment"
+    table.field_names = ["Property", "Value"]
+    table.align["Property"] = "l"
+    table.align["Value"] = "l"
+    table.add_row(["Number of environments", self.num_envs])
+    table.add_row(["Environment device", self.device])
+    table.add_row(["Environment seed", self.cfg.seed])
+    table.add_row(["Physics step-size", self.physics_dt])
+    table.add_row(["Environment step-size", self.step_dt])
+    print_info(table.get_string())
+    print_info("")
+
+    # Initialize RL-specific state.
+    self.common_step_counter = 0
+    self.episode_length_buf = torch.zeros(
+      cfg.scene.num_envs, device=device, dtype=torch.long
+    )
+    self.render_mode = render_mode
+    self._offline_renderer: OffscreenRenderer | None = None
+    if self.render_mode == "rgb_array":
+      renderer = OffscreenRenderer(
+        model=self.sim.mj_model,
+        cfg=self.cfg.viewer,
+        scene=self.scene,
+        sim_model=self.sim.model,
+        expanded_fields=self.sim.expanded_fields,
+      )
+      renderer.initialize()
+      self._offline_renderer = renderer
+    self.metadata["render_fps"] = 1.0 / self.step_dt
+
+    # Load all managers.
+    self.load_managers()
+    self.setup_manager_visualizers()
+
+  # Properties.
+
+  @property
+  def num_envs(self) -> int:
+    """Number of parallel environments."""
+    return self.scene.num_envs
+
+  @property
+  def physics_dt(self) -> float:
+    """Physics simulation step size."""
+    return self.cfg.sim.mujoco.timestep
+
+  @property
+  def step_dt(self) -> float:
+    """Environment step size (physics_dt * decimation)."""
+    return self.cfg.sim.mujoco.timestep * self.cfg.decimation
+
+  @property
+  def device(self) -> str:
+    """Device for computation."""
+    return self.sim.device
+
+  @property
+  def max_episode_length_s(self) -> float:
+    """Maximum episode length in seconds."""
+    return self.cfg.episode_length_s
+
+  @property
+  def max_episode_length(self) -> int:
+    """Maximum episode length in steps."""
+    return math.ceil(self.max_episode_length_s / self.step_dt)
+
+  @property
+  def unwrapped(self) -> "ManagerBasedRlEnv":
+    """Get the unwrapped environment (base case for wrapper chains)."""
+    return self
+
+  # Methods.
+
+  def setup_manager_visualizers(self) -> None:
+    self.manager_visualizers = {}
+    if getattr(self.command_manager, "active_terms", None):
+      self.manager_visualizers["command_manager"] = self.command_manager
+    self.manager_visualizers["event_manager"] = self.event_manager
+    self.manager_visualizers["reward_manager"] = self.reward_manager
+
+  def load_managers(self) -> None:
+    """Load and initialize all managers.
+
+    Order is important! Event and command managers must be loaded first,
+    then action and observation managers, then other RL managers.
+    """
+    # Event manager (required before everything else for domain randomization).
+    self.event_manager = EventManager(self.cfg.events, self)
+    print_info(f"[INFO] {self.event_manager}")
+
+    self.sim.expand_model_fields(self.event_manager.domain_randomization_fields)
+
+    # Command manager (must be before observation manager since observations
+    # may reference commands).
+    if len(self.cfg.commands) > 0:
+      self.command_manager = CommandManager(self.cfg.commands, self)
+    else:
+      self.command_manager = NullCommandManager()
+    print_info(f"[INFO] {self.command_manager}")
+
+    # Action and observation managers.
+    self.action_manager = ActionManager(self.cfg.actions, self)
+    print_info(f"[INFO] {self.action_manager}")
+    self.observation_manager = ObservationManager(self.cfg.observations, self)
+    print_info(f"[INFO] {self.observation_manager}")
+
+    # Other RL-specific managers.
+
+    self.termination_manager = TerminationManager(self.cfg.terminations, self)
+    print_info(f"[INFO] {self.termination_manager}")
+    self.reward_manager = RewardManager(
+      self.cfg.rewards, self, scale_by_dt=self.cfg.scale_rewards_by_dt
+    )
+    print_info(f"[INFO] {self.reward_manager}")
+    if len(self.cfg.curriculum) > 0:
+      self.curriculum_manager = CurriculumManager(self.cfg.curriculum, self)
+    else:
+      self.curriculum_manager = NullCurriculumManager()
+    print_info(f"[INFO] {self.curriculum_manager}")
+    if len(self.cfg.metrics) > 0:
+      self.metrics_manager = MetricsManager(self.cfg.metrics, self)
+    else:
+      self.metrics_manager = NullMetricsManager()
+    print_info(f"[INFO] {self.metrics_manager}")
+    if len(self.cfg.recorders) > 0:
+      self.recorder_manager = RecorderManager(self.cfg.recorders, self)
+    else:
+      self.recorder_manager = NullRecorderManager()
+    print_info(f"[INFO] {self.recorder_manager}")
+
+    # Configure spaces for the environment.
+    self._configure_gym_env_spaces()
+
+    # Initialize startup events if defined.
+    if "startup" in self.event_manager.available_modes:
+      self.event_manager.apply(mode="startup")
+
+  def reset(
+    self,
+    *,
+    seed: int | None = None,
+    env_ids: torch.Tensor | None = None,
+    options: dict[str, Any] | None = None,
+  ) -> tuple[types.VecEnvObs, dict]:
+    del options  # Unused.
+    if env_ids is None:
+      env_ids = torch.arange(self.num_envs, dtype=torch.int64, device=self.device)
+    if seed is not None:
+      self.seed(seed)
+    self.extras["log"] = dict()
+    self._reset_idx(env_ids)
+    self.scene.write_data_to_sim()
+    self.sim.forward()
+    # Scoped to env_ids so a partial reset does not advance stateful commands in the
+    # other envs.
+    self.command_manager.compute(dt=0.0, env_ids=env_ids)
+    self.sim.sense()
+    # Scoped to env_ids: only the reset envs' history/delay buffers receive
+    # the post-reset frame; other envs' observation timelines are untouched.
+    self.obs_buf = self.observation_manager.compute(
+      update_history=True, env_ids=env_ids
+    )
+    self.recorder_manager.record_post_reset(env_ids)
+    return self.obs_buf, self.extras
+
+  def step(self, action: torch.Tensor) -> types.VecEnvStepReturn:
+    """Run one environment step: apply actions, simulate, compute RL signals.
+
+    When ``auto_reset=True`` (default), environments that terminate or time out are
+    reset in place and the returned observation is the post-reset state. When
+    ``auto_reset=False``, the reset is skipped and the returned observation is the
+    terminal state; the caller must call ``reset(env_ids=...)`` for done envs before
+    the next ``step()``.
+
+    **Forward-call placement.** MuJoCo's ``mj_step`` runs forward kinematics *before*
+    integration, so after stepping, derived quantities (``xpos``, ``xquat``,
+    ``site_xpos``, ``cvel``, ``sensordata``) lag ``qpos``/``qvel`` by one physics
+    substep. Rather than calling ``sim.forward()`` twice (once after the decimation
+    loop and once after the reset block), this method calls it **once**, right
+    before observation computation. This single call refreshes derived quantities
+    for *all* envs: non-reset envs pick up post-decimation kinematics, reset envs
+    pick up post-reset kinematics.
+
+    The tradeoff is that termination, reward, and step/interval event managers see
+    derived quantities that are stale by one physics substep (the last ``mj_step``
+    ran ``mj_forward`` from *pre*-integration ``qpos``). In practice, the staleness
+    is negligible for reward shaping, termination checks, and event perturbations.
+    Critically, the staleness is *consistent*: every env, every step, always sees
+    the same lag, so the MDP is well-defined and the value function can learn the
+    correct mapping.
+
+    **Auto-reset parity.** Auto-reset reproduces the explicit ``reset()`` flow:
+    events fire on the terminal state before the reset, and freshly reset envs
+    advance commands with ``dt=0`` so their timers start full.
+
+    .. note::
+
+      Events and reset-path resamples all run *before* ``forward()``, so state
+      they write (e.g. a velocity push) is refreshed automatically and visible
+      in this step's observations. Command updates run *after*
+      the call, so a command that writes sim state must refresh derived
+      quantities itself (see ``MotionCommand._update_command``). In all cases,
+      do not read derived quantities (``root_link_pose_w``, ``body_link_vel_w``,
+      etc.) in the same function that writes state (``write_root_state_to_sim``,
+      ``write_joint_state_to_sim``, etc.). See :ref:`faq` for details.
+    """
+    if not self.cfg.auto_reset and torch.any(self._manual_reset_pending):
+      pending_ids = self._manual_reset_pending.nonzero(as_tuple=False).squeeze(-1)
+      raise RuntimeError(
+        f"Environments {pending_ids.cpu().tolist()} must be reset via "
+        "reset(env_ids=...) before calling step() again when auto_reset=False."
+      )
+
+    self.extras["log"] = dict()
+    self.action_manager.process_action(action.to(self.device))
+
+    for _ in range(self.cfg.decimation):
+      self._sim_step_counter += 1
+      self.action_manager.apply_action()
+      self.scene.write_data_to_sim()
+      self.sim.step()
+      self.scene.update(dt=self.physics_dt)
+      self.metrics_manager.compute_substep()
+
+    # Update env counters.
+    self.episode_length_buf += 1
+    self.common_step_counter += 1
+
+    # Check terminations and compute rewards.
+    # NOTE: Derived quantities (xpos, xquat, ...) are stale by one physics
+    # substep here. See the docstring above for why this is acceptable.
+    self.reset_buf = self.termination_manager.compute()
+    self.reset_terminated = self.termination_manager.terminated
+    self.reset_time_outs = self.termination_manager.time_outs
+
+    self.reward_buf = self.reward_manager.compute(dt=self.step_dt)
+    self.metrics_manager.compute()
+
+    # Events fire before auto-reset, on the terminal state, matching the
+    # explicit flow. Staleness and forward() rules are the same as for
+    # termination/reward (see docstring above).
+    if "step" in self.event_manager.available_modes:
+      self.event_manager.apply(mode="step", dt=self.step_dt)
+    if "interval" in self.event_manager.available_modes:
+      self.event_manager.apply(mode="interval", dt=self.step_dt)
+
+    # Reset envs that terminated/timed-out and log the episode info.
+    reset_env_ids = self.reset_buf.nonzero(as_tuple=False).squeeze(-1)
+    if self.cfg.auto_reset and len(reset_env_ids) > 0:
+      self.recorder_manager.record_pre_reset(reset_env_ids)
+      self._reset_idx(reset_env_ids)
+      self.scene.write_data_to_sim()
+
+    # Single forward() call: recompute derived quantities from current
+    # qpos/qvel for every env. For non-reset envs this resolves the
+    # one-substep staleness left by mj_step; for reset envs it picks up
+    # the freshly written reset state.
+    self.sim.forward()
+
+    # Pass dt=0 for freshly reset envs so their command timers start full,
+    # matching reset().
+    if self.cfg.auto_reset and len(reset_env_ids) > 0:
+      command_dt = self._command_dt
+      command_dt.fill_(self.step_dt)
+      command_dt[reset_env_ids] = 0.0
+      self.command_manager.compute(dt=command_dt)
+    else:
+      self.command_manager.compute(dt=self.step_dt)
+
+    self.sim.sense()
+    self.obs_buf = self.observation_manager.compute(update_history=True)
+
+    if self.cfg.auto_reset and len(reset_env_ids) > 0:
+      self.recorder_manager.record_post_reset(reset_env_ids)
+    elif len(reset_env_ids) > 0:
+      self._manual_reset_pending[reset_env_ids] = True
+
+    self.recorder_manager.record_post_step()
+
+    return (
+      self.obs_buf,
+      self.reward_buf,
+      self.reset_terminated,
+      self.reset_time_outs,
+      self.extras,
+    )
+
+  def get_observations(self) -> dict:
+    return self.observation_manager.compute()
+
+  def render(self) -> np.ndarray | None:
+    if self.render_mode == "human" or self.render_mode is None:
+      return None
+    elif self.render_mode == "rgb_array":
+      if self._offline_renderer is None:
+        raise ValueError("Offline renderer not initialized")
+      debug_callback = (
+        self.update_visualizers if hasattr(self, "update_visualizers") else None
+      )
+      self._offline_renderer.update(self.sim.data, debug_vis_callback=debug_callback)
+      return self._offline_renderer.render()
+    else:
+      raise NotImplementedError(
+        f"Render mode {self.render_mode} is not supported. "
+        f"Please use: {self.metadata['render_modes']}."
+      )
+
+  def close(self) -> None:
+    if self._offline_renderer is not None:
+      self._offline_renderer.close()
+    self.recorder_manager.close()
+
+  @staticmethod
+  def seed(seed: int = -1) -> int:
+    if seed == -1:
+      seed = np.random.randint(0, 10_000)
+    print_info(f"Setting seed: {seed}")
+    random_utils.seed_rng(seed)
+    return seed
+
+  def update_visualizers(self, visualizer: DebugVisualizer) -> None:
+    for mod in self.manager_visualizers.values():
+      mod.debug_vis(visualizer)
+    for sensor in self.scene.sensors.values():
+      sensor.debug_vis(visualizer)
+
+  # Private methods.
+
+  def _configure_gym_env_spaces(self) -> None:
+    from mjlab.utils.spaces import batch_space
+
+    self.single_observation_space = DictSpace()
+    for group_name, group_term_names in self.observation_manager.active_terms.items():
+      has_concatenated_obs = self.observation_manager.group_obs_concatenate[group_name]
+      group_dim = self.observation_manager.group_obs_dim[group_name]
+      if has_concatenated_obs:
+        assert isinstance(group_dim, tuple)
+        self.single_observation_space.spaces[group_name] = Box(
+          shape=group_dim, low=-math.inf, high=math.inf
+        )
+      else:
+        assert not isinstance(group_dim, tuple)
+        group_term_cfgs = self.observation_manager._group_obs_term_cfgs[group_name]
+        # Create a nested dict for this group.
+        group_space = DictSpace()
+        for term_name, term_dim, _term_cfg in zip(
+          group_term_names, group_dim, group_term_cfgs, strict=False
+        ):
+          group_space.spaces[term_name] = Box(
+            shape=term_dim, low=-math.inf, high=math.inf
+          )
+        self.single_observation_space.spaces[group_name] = group_space
+
+    action_dim = sum(self.action_manager.action_term_dim)
+    self.single_action_space = Box(shape=(action_dim,), low=-math.inf, high=math.inf)
+
+    self.observation_space = batch_space(self.single_observation_space, self.num_envs)
+    self.action_space = batch_space(self.single_action_space, self.num_envs)
+
+  def _reset_idx(self, env_ids: torch.Tensor | None = None) -> None:
+    self.curriculum_manager.compute(env_ids=env_ids)
+    self.sim.reset(env_ids)
+    self.scene.reset(env_ids)
+
+    if "reset" in self.event_manager.available_modes:
+      env_step_count = self._sim_step_counter // self.cfg.decimation
+      self.event_manager.apply(
+        mode="reset", env_ids=env_ids, global_env_step_count=env_step_count
+      )
+
+    # NOTE: This is order sensitive.
+    # observation manager.
+    info = self.observation_manager.reset(env_ids)
+    self.extras["log"].update(info)
+    # action manager.
+    info = self.action_manager.reset(env_ids)
+    self.extras["log"].update(info)
+    # rewards manager.
+    info = self.reward_manager.reset(env_ids)
+    self.extras["log"].update(info)
+    # metrics manager.
+    info = self.metrics_manager.reset(env_ids)
+    self.extras["log"].update(info)
+    # curriculum manager.
+    info = self.curriculum_manager.reset(env_ids)
+    self.extras["log"].update(info)
+    # command manager.
+    info = self.command_manager.reset(env_ids)
+    self.extras["log"].update(info)
+    # event manager.
+    info = self.event_manager.reset(env_ids)
+    self.extras["log"].update(info)
+    # termination manager.
+    info = self.termination_manager.reset(env_ids)
+    self.extras["log"].update(info)
+    # reset the episode length buffer.
+    self.episode_length_buf[env_ids] = 0
+    self._manual_reset_pending[env_ids] = False
diff --git a/src/mjlab/envs/mdp/__init__.py b/src/mjlab/envs/mdp/__init__.py
new file mode 100644
index 0000000..a299ae0
--- /dev/null
+++ b/src/mjlab/envs/mdp/__init__.py
@@ -0,0 +1,8 @@
+from . import dr as dr
+from .actions import *  # noqa: F403
+from .curriculums import *  # noqa: F403
+from .events import *  # noqa: F403
+from .metrics import *  # noqa: F403
+from .observations import *  # noqa: F403
+from .rewards import *  # noqa: F403
+from .terminations import *  # noqa: F403
diff --git a/src/mjlab/envs/mdp/actions/__init__.py b/src/mjlab/envs/mdp/actions/__init__.py
new file mode 100644
index 0000000..a3eea95
--- /dev/null
+++ b/src/mjlab/envs/mdp/actions/__init__.py
@@ -0,0 +1,36 @@
+from mjlab.envs.mdp.actions.actions import JointEffortAction as JointEffortAction
+from mjlab.envs.mdp.actions.actions import JointEffortActionCfg as JointEffortActionCfg
+from mjlab.envs.mdp.actions.actions import JointPositionAction as JointPositionAction
+from mjlab.envs.mdp.actions.actions import (
+  JointPositionActionCfg as JointPositionActionCfg,
+)
+from mjlab.envs.mdp.actions.actions import JointVelocityAction as JointVelocityAction
+from mjlab.envs.mdp.actions.actions import (
+  JointVelocityActionCfg as JointVelocityActionCfg,
+)
+from mjlab.envs.mdp.actions.actions import (
+  RelativeJointPositionAction as RelativeJointPositionAction,
+)
+from mjlab.envs.mdp.actions.actions import (
+  RelativeJointPositionActionCfg as RelativeJointPositionActionCfg,
+)
+from mjlab.envs.mdp.actions.actions import SiteEffortAction as SiteEffortAction
+from mjlab.envs.mdp.actions.actions import SiteEffortActionCfg as SiteEffortActionCfg
+from mjlab.envs.mdp.actions.actions import TendonEffortAction as TendonEffortAction
+from mjlab.envs.mdp.actions.actions import (
+  TendonEffortActionCfg as TendonEffortActionCfg,
+)
+from mjlab.envs.mdp.actions.actions import TendonLengthAction as TendonLengthAction
+from mjlab.envs.mdp.actions.actions import (
+  TendonLengthActionCfg as TendonLengthActionCfg,
+)
+from mjlab.envs.mdp.actions.actions import TendonVelocityAction as TendonVelocityAction
+from mjlab.envs.mdp.actions.actions import (
+  TendonVelocityActionCfg as TendonVelocityActionCfg,
+)
+from mjlab.envs.mdp.actions.differential_ik import (
+  DifferentialIKAction as DifferentialIKAction,
+)
+from mjlab.envs.mdp.actions.differential_ik import (
+  DifferentialIKActionCfg as DifferentialIKActionCfg,
+)
diff --git a/src/mjlab/envs/mdp/actions/actions.py b/src/mjlab/envs/mdp/actions/actions.py
new file mode 100644
index 0000000..b9ba67d
--- /dev/null
+++ b/src/mjlab/envs/mdp/actions/actions.py
@@ -0,0 +1,386 @@
+"""Actions that control actuator transmissions (e.g., joints, tendons, sites)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.actuator.actuator import TransmissionType
+from mjlab.managers.action_manager import ActionTerm, ActionTermCfg
+from mjlab.utils.lab_api.string import resolve_matching_names_values
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+@dataclass(kw_only=True)
+class BaseActionCfg(ActionTermCfg):
+  """Configuration for actions that control actuator transmissions."""
+
+  transmission_type: TransmissionType = TransmissionType.JOINT
+  """Type of transmission to control."""
+
+  actuator_names: tuple[str, ...] | list[str]
+  """Actuator names to control."""
+
+  scale: float | dict[str, float] = 1.0
+  """Action scale. Float or dict mapping actuator names to scales."""
+
+  offset: float | dict[str, float] = 0.0
+  """Action offset. Float or dict mapping actuator names to offsets."""
+
+  preserve_order: bool = False
+  """Whether to preserve the order of actuator names."""
+
+
+class BaseAction(ActionTerm):
+  """Apply actions to actuator transmissions with scale/offset processing.
+
+  Supports controlling different transmission types (e.g., joints, tendons,
+  sites) with configurable affine transformations applied to raw actions.
+  """
+
+  cfg: BaseActionCfg
+  _entity: Entity
+
+  def __init__(self, cfg: BaseActionCfg, env: ManagerBasedRlEnv):
+    super().__init__(cfg=cfg, env=env)
+
+    # Find targets based on transmission type.
+    target_ids, target_names = self._find_targets(cfg)
+    self._target_ids = torch.tensor(target_ids, device=self.device, dtype=torch.long)
+    self._target_names = target_names
+
+    self._num_targets = len(target_ids)
+    self._action_dim = len(target_ids)
+
+    self._raw_actions = torch.zeros(self.num_envs, self.action_dim, device=self.device)
+    self._processed_actions = torch.zeros_like(self._raw_actions)
+
+    if isinstance(cfg.scale, (float, int)):
+      self._scale = float(cfg.scale)
+    elif isinstance(cfg.scale, dict):
+      self._scale = torch.ones(self.num_envs, self.action_dim, device=self.device)
+      index_list, _, value_list = resolve_matching_names_values(
+        cfg.scale, self._target_names
+      )
+      self._scale[:, index_list] = torch.tensor(value_list, device=self.device)
+    else:
+      raise ValueError(
+        f"Unsupported scale type: {type(cfg.scale)}. "
+        f"Supported types are float and dict."
+      )
+
+    if isinstance(cfg.offset, (float, int)):
+      self._offset = float(cfg.offset)
+    elif isinstance(cfg.offset, dict):
+      self._offset = torch.zeros_like(self._raw_actions)
+      index_list, _, value_list = resolve_matching_names_values(
+        cfg.offset, self._target_names
+      )
+      self._offset[:, index_list] = torch.tensor(value_list, device=self.device)
+    else:
+      raise ValueError(
+        f"Unsupported offset type: {type(cfg.offset)}. "
+        f"Supported types are float and dict."
+      )
+
+    if cfg.clip is not None:
+      self._clip = torch.tensor(
+        [[-float("inf"), float("inf")]], device=self.device
+      ).repeat(self.num_envs, self.action_dim, 1)
+      index_list, _, value_list = resolve_matching_names_values(
+        cfg.clip, self._target_names
+      )
+      self._clip[:, index_list] = torch.tensor(value_list, device=self.device)
+
+  def _find_targets(self, cfg: BaseActionCfg) -> tuple[list[int], list[str]]:
+    """Find target IDs and names based on transmission type.
+
+    Args:
+      cfg: Action configuration.
+
+    Returns:
+      Tuple of (target_ids, target_names).
+    """
+    if cfg.transmission_type == TransmissionType.JOINT:
+      return self._entity.find_joints_by_actuator_names(cfg.actuator_names)
+    elif cfg.transmission_type == TransmissionType.TENDON:
+      return self._entity.find_tendons(
+        cfg.actuator_names, preserve_order=cfg.preserve_order
+      )
+    elif cfg.transmission_type == TransmissionType.SITE:
+      return self._entity.find_sites(
+        cfg.actuator_names, preserve_order=cfg.preserve_order
+      )
+    else:
+      raise ValueError(f"Unknown transmission type: {cfg.transmission_type}")
+
+  # Properties.
+
+  @property
+  def scale(self) -> torch.Tensor | float:
+    """Action scale."""
+    return self._scale
+
+  @property
+  def offset(self) -> torch.Tensor | float:
+    """Action offset."""
+    return self._offset
+
+  @property
+  def raw_action(self) -> torch.Tensor:
+    """Raw actions (before scale/offset)."""
+    return self._raw_actions
+
+  @property
+  def action_dim(self) -> int:
+    """Dimension of the action space."""
+    return self._action_dim
+
+  @property
+  def target_ids(self) -> torch.Tensor:
+    """Target IDs for the controlled transmission."""
+    return self._target_ids
+
+  @property
+  def target_names(self) -> list[str]:
+    """Target names for the controlled transmission."""
+    return self._target_names
+
+  def process_actions(self, actions: torch.Tensor):
+    """Process raw actions by applying scale, offset, and optional clip."""
+    self._raw_actions[:] = actions
+    self._processed_actions = self._raw_actions * self._scale + self._offset
+    if self.cfg.clip is not None:
+      self._processed_actions = torch.clamp(
+        self._processed_actions,
+        min=self._clip[:, :, 0],
+        max=self._clip[:, :, 1],
+      )
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    """Reset raw actions to zero for specified environments."""
+    self._raw_actions[env_ids] = 0.0
+
+
+##
+# Joint actions.
+##
+
+
+@dataclass(kw_only=True)
+class JointPositionActionCfg(BaseActionCfg):
+  """Configuration for joint position control."""
+
+  use_default_offset: bool = True
+
+  def __post_init__(self):
+    self.transmission_type = TransmissionType.JOINT
+
+  def build(self, env: ManagerBasedRlEnv) -> JointPositionAction:
+    return JointPositionAction(self, env)
+
+
+@dataclass(kw_only=True)
+class JointVelocityActionCfg(BaseActionCfg):
+  """Configuration for joint velocity control."""
+
+  use_default_offset: bool = True
+
+  def __post_init__(self):
+    self.transmission_type = TransmissionType.JOINT
+
+  def build(self, env: ManagerBasedRlEnv) -> JointVelocityAction:
+    return JointVelocityAction(self, env)
+
+
+@dataclass(kw_only=True)
+class JointEffortActionCfg(BaseActionCfg):
+  """Configuration for joint effort (torque) control."""
+
+  def __post_init__(self):
+    self.transmission_type = TransmissionType.JOINT
+
+  def build(self, env: ManagerBasedRlEnv) -> JointEffortAction:
+    return JointEffortAction(self, env)
+
+
+class JointPositionAction(BaseAction):
+  """Control joints via position targets."""
+
+  def __init__(self, cfg: JointPositionActionCfg, env: ManagerBasedRlEnv):
+    super().__init__(cfg=cfg, env=env)
+
+    if cfg.use_default_offset:
+      self._offset = self._entity.data.default_joint_pos[:, self._target_ids].clone()
+
+  def apply_actions(self) -> None:
+    encoder_bias = self._entity.data.encoder_bias[:, self._target_ids]
+    target = self._processed_actions - encoder_bias
+    self._entity.set_joint_position_target(target, joint_ids=self._target_ids)
+
+
+@dataclass(kw_only=True)
+class RelativeJointPositionActionCfg(BaseActionCfg):
+  """Configuration for joint position control relative to current positions.
+
+  target = current_joint_pos + action * scale
+
+  The ``offset`` field inherited from ``BaseActionCfg`` is not supported and
+  must remain at its default of ``0.0``. The ``clip`` field is supported and
+  clamps the delta (``action * scale``) before it is added to the current
+  position.
+  """
+
+  def __post_init__(self):
+    self.transmission_type = TransmissionType.JOINT
+    if self.offset != 0.0:
+      raise ValueError(
+        "RelativeJointPositionActionCfg does not support 'offset'. "
+        "The target is current_pos + action * scale; a fixed offset has no meaning."
+      )
+
+  def build(self, env: ManagerBasedRlEnv) -> RelativeJointPositionAction:
+    return RelativeJointPositionAction(self, env)
+
+
+class RelativeJointPositionAction(BaseAction):
+  """Control joints via position targets relative to current positions."""
+
+  def apply_actions(self) -> None:
+    current_pos = self._entity.data.joint_pos[:, self._target_ids]
+    target = current_pos + self._processed_actions
+    self._entity.set_joint_position_target(target, joint_ids=self._target_ids)
+
+
+class JointVelocityAction(BaseAction):
+  """Control joints via velocity targets."""
+
+  def __init__(self, cfg: JointVelocityActionCfg, env: ManagerBasedRlEnv):
+    super().__init__(cfg=cfg, env=env)
+
+    if cfg.use_default_offset:
+      self._offset = self._entity.data.default_joint_vel[:, self._target_ids].clone()
+
+  def apply_actions(self) -> None:
+    self._entity.set_joint_velocity_target(
+      self._processed_actions, joint_ids=self._target_ids
+    )
+
+
+class JointEffortAction(BaseAction):
+  """Control joints via effort (torque) targets."""
+
+  def __init__(self, cfg: JointEffortActionCfg, env: ManagerBasedRlEnv):
+    super().__init__(cfg=cfg, env=env)
+
+  def apply_actions(self) -> None:
+    self._entity.set_joint_effort_target(
+      self._processed_actions, joint_ids=self._target_ids
+    )
+
+
+##
+# Tendon actions.
+##
+
+
+@dataclass(kw_only=True)
+class TendonLengthActionCfg(BaseActionCfg):
+  """Configuration for tendon length control."""
+
+  def __post_init__(self):
+    self.transmission_type = TransmissionType.TENDON
+
+  def build(self, env: ManagerBasedRlEnv) -> TendonLengthAction:
+    return TendonLengthAction(self, env)
+
+
+@dataclass(kw_only=True)
+class TendonVelocityActionCfg(BaseActionCfg):
+  """Configuration for tendon velocity control."""
+
+  def __post_init__(self):
+    self.transmission_type = TransmissionType.TENDON
+
+  def build(self, env: ManagerBasedRlEnv) -> TendonVelocityAction:
+    return TendonVelocityAction(self, env)
+
+
+@dataclass(kw_only=True)
+class TendonEffortActionCfg(BaseActionCfg):
+  """Configuration for tendon effort control."""
+
+  def __post_init__(self):
+    self.transmission_type = TransmissionType.TENDON
+
+  def build(self, env: ManagerBasedRlEnv) -> TendonEffortAction:
+    return TendonEffortAction(self, env)
+
+
+class TendonLengthAction(BaseAction):
+  """Control tendons via length targets."""
+
+  def __init__(self, cfg: TendonLengthActionCfg, env: ManagerBasedRlEnv):
+    super().__init__(cfg=cfg, env=env)
+
+  def apply_actions(self) -> None:
+    self._entity.set_tendon_len_target(
+      self._processed_actions, tendon_ids=self._target_ids
+    )
+
+
+class TendonVelocityAction(BaseAction):
+  """Control tendons via velocity targets."""
+
+  def __init__(self, cfg: TendonVelocityActionCfg, env: ManagerBasedRlEnv):
+    super().__init__(cfg=cfg, env=env)
+
+  def apply_actions(self) -> None:
+    self._entity.set_tendon_vel_target(
+      self._processed_actions, tendon_ids=self._target_ids
+    )
+
+
+class TendonEffortAction(BaseAction):
+  """Control tendons via effort targets."""
+
+  def __init__(self, cfg: TendonEffortActionCfg, env: ManagerBasedRlEnv):
+    super().__init__(cfg=cfg, env=env)
+
+  def apply_actions(self) -> None:
+    self._entity.set_tendon_effort_target(
+      self._processed_actions, tendon_ids=self._target_ids
+    )
+
+
+##
+# Site actions.
+##
+
+
+@dataclass(kw_only=True)
+class SiteEffortActionCfg(BaseActionCfg):
+  """Configuration for site effort control."""
+
+  def __post_init__(self):
+    self.transmission_type = TransmissionType.SITE
+
+  def build(self, env: ManagerBasedRlEnv) -> SiteEffortAction:
+    return SiteEffortAction(self, env)
+
+
+class SiteEffortAction(BaseAction):
+  """Control sites via effort targets."""
+
+  def __init__(self, cfg: SiteEffortActionCfg, env: ManagerBasedRlEnv):
+    super().__init__(cfg=cfg, env=env)
+
+  def apply_actions(self) -> None:
+    self._entity.set_site_effort_target(
+      self._processed_actions, site_ids=self._target_ids
+    )
diff --git a/src/mjlab/envs/mdp/actions/differential_ik.py b/src/mjlab/envs/mdp/actions/differential_ik.py
new file mode 100644
index 0000000..c228c5e
--- /dev/null
+++ b/src/mjlab/envs/mdp/actions/differential_ik.py
@@ -0,0 +1,314 @@
+"""Differential IK action space for task-space control."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal
+
+import mujoco_warp as mjwarp
+import torch
+import warp as wp
+
+from mjlab.managers.action_manager import ActionTerm, ActionTermCfg
+from mjlab.utils.lab_api.math import (
+  apply_delta_pose,
+  compute_pose_error,
+  quat_from_matrix,
+)
+from mjlab.utils.string import resolve_expr
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+@dataclass(kw_only=True)
+class DifferentialIKActionCfg(ActionTermCfg):
+  """Configuration for differential IK action space.
+
+  Converts task-space commands (position and/or orientation) into
+  joint-space targets via damped least-squares (DLS) IK, applied
+  every decimation substep.
+
+  The action dimension is determined by the active objectives:
+
+  - ``position_weight > 0, orientation_weight == 0`` -> 3D
+  - ``orientation_weight > 0, use_relative_mode=True`` -> 6D
+  - ``orientation_weight > 0, use_relative_mode=False`` -> 7D
+  """
+
+  actuator_names: tuple[str, ...] | list[str]
+  """Actuator name expressions to resolve the controlled joints."""
+
+  frame_type: Literal["body", "site", "geom"] = "body"
+  """Element type of the target frame."""
+
+  frame_name: str
+  """Name of the target frame element on the entity."""
+
+  use_relative_mode: bool = True
+  """If True, actions are deltas applied to the current frame pose.
+  If False, actions are absolute targets."""
+
+  delta_pos_scale: float = 1.0
+  """Scaling factor for position components in relative mode.
+
+  Maps raw policy outputs to position deltas (meters).
+  Ignored in absolute mode.
+  """
+
+  delta_ori_scale: float = 1.0
+  """Scaling factor for orientation components in relative mode.
+
+  Maps raw policy outputs to orientation deltas (radians).
+  Ignored in absolute mode.
+  """
+
+  damping: float = 0.05
+  """Damping coefficient (lambda) for the DLS pseudoinverse."""
+
+  max_dq: float = 0.5
+  """Maximum joint displacement per IK solve (rad/step)."""
+
+  position_weight: float = 1.0
+  """Weight for the position residual in the DLS system."""
+
+  orientation_weight: float = 1.0
+  """Weight for the orientation residual (0 = position-only mode)."""
+
+  joint_limit_weight: float = 0.0
+  """Weight for soft joint-limit residuals (0 = disabled).
+
+  When positive, joint-limit violations are added as extra rows
+  in the DLS system so the solver steers away from limits.
+  """
+
+  posture_weight: float = 0.0
+  """Weight for posture regularization (0 = disabled).
+
+  When positive, a residual ``w * (q_target - q_current)`` is added
+  to bias the solver toward the posture target. Useful with
+  redundant manipulators or position-only tracking to control
+  null-space behaviour.
+  """
+
+  posture_target: dict[str, float] | None = None
+  """Target joint positions for posture regularization.
+
+  Maps joint name patterns to target values (same format as
+  ``EntityCfg.InitialStateCfg.joint_pos``). Joints not listed
+  default to their initial (qpos0) value. Only used when
+  ``posture_weight > 0``.
+  """
+
+  def build(self, env: ManagerBasedRlEnv) -> DifferentialIKAction:
+    return DifferentialIKAction(self, env)
+
+
+class DifferentialIKAction(ActionTerm):
+  """Converts task-space commands into joint position targets via damped least-squares
+  IK each decimation substep.
+  """
+
+  cfg: DifferentialIKActionCfg
+  _entity: Entity
+
+  def __init__(self, cfg: DifferentialIKActionCfg, env: ManagerBasedRlEnv):
+    super().__init__(cfg=cfg, env=env)
+
+    joint_ids, _ = self._entity.find_joints_by_actuator_names(cfg.actuator_names)
+    self._joint_ids = torch.tensor(joint_ids, device=self.device, dtype=torch.long)
+    self._num_joints = len(joint_ids)
+    self._joint_dof_ids = self._entity.indexing.joint_v_adr[self._joint_ids]
+
+    self._frame_type = cfg.frame_type
+    self._resolve_frame(cfg.frame_name)
+
+    if cfg.orientation_weight > 0:
+      self._action_dim = 6 if cfg.use_relative_mode else 7
+    else:
+      self._action_dim = 3
+    self._raw_actions = torch.zeros(self.num_envs, self._action_dim, device=self.device)
+
+    self._desired_pos = torch.zeros(self.num_envs, 3, device=self.device)
+    self._desired_quat = torch.zeros(self.num_envs, 4, device=self.device)
+    self._desired_quat[:, 0] = 1.0
+
+    # Joint-limit buffers.
+    limits = self._entity.data.soft_joint_pos_limits
+    self._joint_lower = limits[:, self._joint_ids, 0]
+    self._joint_upper = limits[:, self._joint_ids, 1]
+
+    # Posture regularization target.
+    q_target = self._entity.data.default_joint_pos[:, self._joint_ids].clone()
+    if cfg.posture_target is not None:
+      joint_names = tuple(self._entity.joint_names[i] for i in joint_ids)
+      overrides = resolve_expr(cfg.posture_target, joint_names)
+      for j, val in enumerate(overrides):
+        if val is not None:
+          q_target[:, j] = val
+    self._posture_target = q_target
+
+    nworld = self.num_envs
+    nv = self._env.sim.mj_model.nv
+
+    with wp.ScopedDevice(self._env.sim.wp_device):
+      self._jacp_wp = wp.zeros((nworld, 3, nv), dtype=float)
+      self._jacr_wp = wp.zeros((nworld, 3, nv), dtype=float)
+      self._point_wp = wp.zeros(nworld, dtype=wp.vec3)
+      self._body_wp = wp.zeros(nworld, dtype=wp.int32)
+      self._body_wp.fill_(self._body_id)
+
+    self._jacp_torch = wp.to_torch(self._jacp_wp)
+    self._jacr_torch = wp.to_torch(self._jacr_wp)
+    self._point_torch = wp.to_torch(self._point_wp).view(nworld, 3)
+
+  @property
+  def action_dim(self) -> int:
+    return self._action_dim
+
+  @property
+  def raw_action(self) -> torch.Tensor:
+    return self._raw_actions
+
+  def process_actions(self, actions: torch.Tensor) -> None:
+    self._raw_actions[:] = actions
+
+    frame_pos, frame_quat = self._get_frame_pose()
+    if self._action_dim == 3:
+      if self.cfg.use_relative_mode:
+        self._desired_pos[:] = frame_pos + actions * self.cfg.delta_pos_scale
+      else:
+        self._desired_pos[:] = actions
+      self._desired_quat[:] = frame_quat
+    elif self._action_dim == 6:
+      delta = actions.clone()
+      delta[:, :3] *= self.cfg.delta_pos_scale
+      delta[:, 3:] *= self.cfg.delta_ori_scale
+      target_pos, target_quat = apply_delta_pose(frame_pos, frame_quat, delta)
+      self._desired_pos[:] = target_pos
+      self._desired_quat[:] = target_quat
+    else:
+      assert self._action_dim == 7
+      self._desired_pos[:] = actions[:, :3]
+      self._desired_quat[:] = actions[:, 3:7]
+
+  def compute_dq(self) -> torch.Tensor:
+    """Run one DLS IK step and return joint displacement.
+
+    Returns:
+      Joint displacement tensor of shape ``(num_envs, num_joints)``.
+    """
+    frame_pos, frame_quat = self._get_frame_pose()
+    pos_error, rot_error = compute_pose_error(
+      frame_pos, frame_quat, self._desired_pos, self._desired_quat
+    )
+
+    self._point_torch[:] = frame_pos
+    self._compute_jacobian()
+    jacp = self._jacp_torch[:, :, self._joint_dof_ids]
+    jacr = self._jacr_torch[:, :, self._joint_dof_ids]
+
+    w_pos = self.cfg.position_weight
+    w_ori = self.cfg.orientation_weight
+    w_lim = self.cfg.joint_limit_weight
+    w_post = self.cfg.posture_weight
+    lam = max(self.cfg.damping, 1e-6)
+
+    # Joint-space normal equations: (J^T W J + λ²I) dq = J^T W dx.
+    # Equivalent to task-space DLS but solves a smaller n×n system instead of the
+    # (6 + 2n)-square task-space system.
+    wp2, wo2 = w_pos * w_pos, w_ori * w_ori
+    JTJ = wp2 * torch.einsum("bti,btj->bij", jacp, jacp) + wo2 * torch.einsum(
+      "bti,btj->bij", jacr, jacr
+    )
+    JTdx = wp2 * torch.einsum("bti,bt->bi", jacp, pos_error) + wo2 * torch.einsum(
+      "bti,bt->bi", jacr, rot_error
+    )
+
+    # Joint-limit penalty (diagonal contribution).
+    q = self._entity.data.joint_pos[:, self._joint_ids]
+    r_limit = (self._joint_upper - q).clamp(max=0) + (self._joint_lower - q).clamp(
+      min=0
+    )
+    violated = (r_limit != 0).float()
+    wl2 = w_lim * w_lim
+    JTJ.diagonal(dim1=-2, dim2=-1).add_(wl2 * violated)
+    JTdx.add_(wl2 * violated * r_limit)
+
+    # Posture regularization (identity Jacobian contribution).
+    r_posture = self._posture_target - q
+    wpost2 = w_post * w_post
+    JTJ.diagonal(dim1=-2, dim2=-1).add_(wpost2)
+    JTdx.add_(wpost2 * r_posture)
+
+    # Damping.
+    JTJ.diagonal(dim1=-2, dim2=-1).add_(lam * lam)
+
+    dq = torch.linalg.solve(JTJ, JTdx)
+    return dq.clamp(-self.cfg.max_dq, self.cfg.max_dq)
+
+  def apply_actions(self) -> None:
+    dq = self.compute_dq()
+    q_current = self._entity.data.joint_pos[:, self._joint_ids]
+    q_target = q_current + dq
+    self._entity.set_joint_position_target(q_target, joint_ids=self._joint_ids)
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    if env_ids is None:
+      env_ids = slice(None)
+    self._raw_actions[env_ids] = 0.0
+    self._desired_pos[env_ids] = 0.0
+    self._desired_quat[env_ids] = 0.0
+    self._desired_quat[env_ids, 0] = 1.0
+
+  # Private
+
+  def _resolve_frame(self, frame_name: str) -> None:
+    """Resolve the frame element to its global ID and parent body ID."""
+    if self._frame_type == "body":
+      ids, _ = self._entity.find_bodies(frame_name)
+      local_id = ids[0]
+      self._frame_id = int(self._entity.indexing.body_ids[local_id].item())
+      self._body_id = self._frame_id
+    elif self._frame_type == "site":
+      ids, _ = self._entity.find_sites(frame_name)
+      local_id = ids[0]
+      self._frame_id = int(self._entity.indexing.site_ids[local_id].item())
+      self._body_id = int(self._env.sim.mj_model.site_bodyid[self._frame_id])
+    elif self._frame_type == "geom":
+      ids, _ = self._entity.find_geoms(frame_name)
+      local_id = ids[0]
+      self._frame_id = int(self._entity.indexing.geom_ids[local_id].item())
+      self._body_id = int(self._env.sim.mj_model.geom_bodyid[self._frame_id])
+    else:
+      raise ValueError(f"Unknown frame_type: {self._frame_type}")
+
+  def _get_frame_pose(self) -> tuple[torch.Tensor, torch.Tensor]:
+    """Return current frame (position, quaternion) from sim data."""
+    data = self._env.sim.data
+    if self._frame_type == "body":
+      pos = data.xpos[:, self._frame_id]
+      quat = data.xquat[:, self._frame_id]
+    elif self._frame_type == "site":
+      pos = data.site_xpos[:, self._frame_id]
+      xmat = data.site_xmat[:, self._frame_id]
+      quat = quat_from_matrix(xmat)
+    else:
+      assert self._frame_type == "geom"
+      pos = data.geom_xpos[:, self._frame_id]
+      xmat = data.geom_xmat[:, self._frame_id]
+      quat = quat_from_matrix(xmat)
+    return pos, quat
+
+  def _compute_jacobian(self) -> None:
+    """Compute the frame Jacobian."""
+    with wp.ScopedDevice(self._env.sim.wp_device):
+      mjwarp.jac(
+        self._env.sim.wp_model,
+        self._env.sim.wp_data,
+        self._jacp_wp,
+        self._jacr_wp,
+        self._point_wp,
+        self._body_wp,
+      )
diff --git a/src/mjlab/envs/mdp/curriculums.py b/src/mjlab/envs/mdp/curriculums.py
new file mode 100644
index 0000000..f19cce8
--- /dev/null
+++ b/src/mjlab/envs/mdp/curriculums.py
@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any, TypedDict
+
+import torch
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+  from mjlab.managers.curriculum_manager import CurriculumTermCfg
+
+
+# Stage schemas.
+
+
+class _RewardCurriculumStageOptional(TypedDict, total=False):
+  weight: float
+  params: dict[str, Any]
+
+
+class RewardCurriculumStage(_RewardCurriculumStageOptional):
+  step: int
+
+
+class _TerminationCurriculumStageOptional(TypedDict, total=False):
+  params: dict[str, Any]
+  time_out: bool
+
+
+class TerminationCurriculumStage(_TerminationCurriculumStageOptional):
+  step: int
+
+
+# Shared engine.  Stage dicts are passed directly from the public TypedDict
+# schemas.  Any key that isn't "step" or "params" is treated as a top-level
+# field on the target term config (e.g. "weight" on RewardTermCfg).
+
+_RESERVED_KEYS = {"step", "params"}
+
+
+def _validate_stages(
+  term_cfg: Any,
+  term_name: str,
+  stages: Sequence[Any],
+) -> None:
+  """Validate stage ordering, field existence, and param keys."""
+  for i in range(1, len(stages)):
+    if stages[i]["step"] < stages[i - 1]["step"]:
+      raise ValueError(
+        f"Curriculum stages must be in nondecreasing step order,"
+        f" but stage {i} has step"
+        f" {stages[i]['step']} < {stages[i - 1]['step']}."
+      )
+  for stage in stages:
+    for key in stage:
+      if key not in _RESERVED_KEYS and not hasattr(term_cfg, key):
+        raise AttributeError(
+          f"Field '{key}' does not exist on the resolved term config for '{term_name}'."
+        )
+  for stage in stages:
+    unknown = stage.get("params", {}).keys() - term_cfg.params.keys()
+    if unknown:
+      raise KeyError(
+        f"Stage at step {stage['step']} sets unknown param(s)"
+        f" {unknown} on term '{term_name}'. Check for typos."
+      )
+
+
+def _apply_stages(
+  term_cfg: Any,
+  step_counter: int,
+  stages: Sequence[Any],
+) -> dict[str, torch.Tensor]:
+  """Apply staged updates and return a logging snapshot."""
+  for stage in stages:
+    if step_counter >= stage["step"]:
+      for key, value in stage.items():
+        if key not in _RESERVED_KEYS:
+          setattr(term_cfg, key, value)
+      if "params" in stage:
+        term_cfg.params.update(stage["params"])
+  # Only log values that stages actually reference.
+  logged_fields: set[str] = set()
+  logged_params: set[str] = set()
+  for stage in stages:
+    for key in stage:
+      if key not in _RESERVED_KEYS:
+        logged_fields.add(key)
+    for key in stage.get("params", {}):
+      logged_params.add(key)
+  result: dict[str, torch.Tensor] = {}
+  for key in logged_fields:
+    value = getattr(term_cfg, key)
+    if isinstance(value, (int, float, bool)):
+      result[key] = torch.tensor(value)
+    elif isinstance(value, torch.Tensor):
+      result[key] = value
+  for key in logged_params:
+    v = term_cfg.params[key]
+    if isinstance(v, (int, float, bool)):
+      result[key] = torch.tensor(v)
+    elif isinstance(v, torch.Tensor):
+      result[key] = v
+  return result
+
+
+# Public wrappers.
+
+
+class reward_curriculum:
+  """Update a reward term's weight and/or params based on training steps.
+
+  Each stage specifies a ``step`` threshold and optionally a ``weight``
+  and/or ``params`` dict.  When ``env.common_step_counter`` reaches a
+  stage's ``step``, the corresponding values are applied.  Later stages
+  take precedence when multiple thresholds are reached.
+
+  Example::
+
+    CurriculumTermCfg(
+      func=mdp.reward_curriculum,
+      params={
+        "reward_name": "joint_vel_hinge",
+        "stages": [
+          {"step": 0, "weight": -0.01},
+          {"step": 12000, "weight": -0.1},
+          {"step": 24000, "weight": -1.0, "params": {"max_vel": 1.0}},
+        ],
+      },
+    )
+  """
+
+  def __init__(self, cfg: CurriculumTermCfg, env: ManagerBasedRlEnv):
+    reward_name: str = cfg.params["reward_name"]
+    stages: list[RewardCurriculumStage] = cfg.params["stages"]
+    self._term_cfg = env.reward_manager.get_term_cfg(reward_name)
+    self._stages = stages
+    _validate_stages(self._term_cfg, reward_name, self._stages)
+
+  def __call__(
+    self,
+    env: ManagerBasedRlEnv,
+    env_ids: torch.Tensor,
+    reward_name: str,
+    stages: list[RewardCurriculumStage],
+  ) -> dict[str, torch.Tensor]:
+    del env_ids, reward_name, stages
+    return _apply_stages(self._term_cfg, env.common_step_counter, self._stages)
+
+
+class termination_curriculum:
+  """Update a termination term's params based on training steps.
+
+  Each stage specifies a ``step`` threshold and a ``params`` dict.  When
+  ``env.common_step_counter`` reaches a stage's ``step``, the params are
+  applied.  Later stages take precedence.
+
+  Example::
+
+    CurriculumTermCfg(
+      func=mdp.termination_curriculum,
+      params={
+        "termination_name": "energy",
+        "stages": [
+          {"step": 12000, "params": {"threshold": 1000.0}},
+          {"step": 24000, "params": {"threshold": 700.0}},
+        ],
+      },
+    )
+  """
+
+  def __init__(self, cfg: CurriculumTermCfg, env: ManagerBasedRlEnv):
+    termination_name: str = cfg.params["termination_name"]
+    stages: list[TerminationCurriculumStage] = cfg.params["stages"]
+    self._term_cfg = env.termination_manager.get_term_cfg(termination_name)
+    self._stages = stages
+    _validate_stages(self._term_cfg, termination_name, self._stages)
+
+  def __call__(
+    self,
+    env: ManagerBasedRlEnv,
+    env_ids: torch.Tensor,
+    termination_name: str,
+    stages: list[TerminationCurriculumStage],
+  ) -> dict[str, torch.Tensor]:
+    del env_ids, termination_name, stages
+    return _apply_stages(self._term_cfg, env.common_step_counter, self._stages)
diff --git a/src/mjlab/envs/mdp/dr/__init__.py b/src/mjlab/envs/mdp/dr/__init__.py
new file mode 100644
index 0000000..db4a2a2
--- /dev/null
+++ b/src/mjlab/envs/mdp/dr/__init__.py
@@ -0,0 +1,95 @@
+"""Domain randomization functions."""
+
+# Types and built-in instances.
+# isort: split
+from ._types import Distribution as Distribution
+from ._types import Operation as Operation
+from ._types import abs as abs
+from ._types import add as add
+from ._types import gaussian as gaussian
+from ._types import log_uniform as log_uniform
+from ._types import scale as scale
+from ._types import uniform as uniform
+
+# Geom.
+# isort: split
+from .geom import geom_friction as geom_friction
+from .geom import geom_matid as geom_matid
+from .geom import geom_pos as geom_pos
+from .geom import geom_quat as geom_quat
+from .geom import geom_rgba as geom_rgba
+from .geom import geom_size as geom_size
+
+# Body.
+# isort: split
+from .body import body_com_offset as body_com_offset
+from .body import body_ipos as body_ipos
+from .body import body_mass as body_mass
+from .body import body_pos as body_pos
+from .body import body_quat as body_quat
+from .body import pseudo_inertia as pseudo_inertia
+
+# Joint / DOF.
+# isort: split
+from .joint import dof_armature as dof_armature
+from .joint import dof_damping as dof_damping
+from .joint import dof_frictionloss as dof_frictionloss
+from .joint import encoder_bias as encoder_bias
+from .joint import jnt_range as jnt_range
+from .joint import jnt_stiffness as jnt_stiffness
+from .joint import joint_armature as joint_armature
+from .joint import joint_damping as joint_damping
+from .joint import joint_default_pos as joint_default_pos
+from .joint import joint_friction as joint_friction
+from .joint import joint_limits as joint_limits
+from .joint import joint_stiffness as joint_stiffness
+from .joint import qpos0 as qpos0
+
+# Site.
+# isort: split
+from .site import site_pos as site_pos
+from .site import site_quat as site_quat
+
+# Tendon.
+# isort: split
+from .tendon import tendon_armature as tendon_armature
+from .tendon import tendon_damping as tendon_damping
+from .tendon import tendon_friction as tendon_friction
+from .tendon import tendon_frictionloss as tendon_frictionloss
+from .tendon import tendon_stiffness as tendon_stiffness
+
+# Camera.
+# isort: split
+from .camera import cam_fovy as cam_fovy
+from .camera import cam_intrinsic as cam_intrinsic
+from .camera import cam_pos as cam_pos
+from .camera import cam_quat as cam_quat
+
+# Light.
+# isort: split
+from .light import light_ambient as light_ambient
+from .light import light_attenuation as light_attenuation
+from .light import light_cutoff as light_cutoff
+from .light import light_diffuse as light_diffuse
+from .light import light_dir as light_dir
+from .light import light_exponent as light_exponent
+from .light import light_pos as light_pos
+from .light import light_specular as light_specular
+
+# Material.
+# isort: split
+from .material import mat_emission as mat_emission
+from .material import mat_rgba as mat_rgba
+from .material import mat_shininess as mat_shininess
+from .material import mat_specular as mat_specular
+from .material import mat_texid as mat_texid
+from .material import mat_texrepeat as mat_texrepeat
+
+# Pair.
+# isort: split
+from .pair import pair_friction as pair_friction
+
+# Actuator.
+# isort: split
+from .actuator import effort_limits as effort_limits
+from .actuator import pd_gains as pd_gains
diff --git a/src/mjlab/envs/mdp/dr/_core.py b/src/mjlab/envs/mdp/dr/_core.py
new file mode 100644
index 0000000..f6803a2
--- /dev/null
+++ b/src/mjlab/envs/mdp/dr/_core.py
@@ -0,0 +1,443 @@
+"""Shared private engine for domain randomization."""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.entity import Entity, EntityIndexing
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.utils.lab_api.math import quat_from_euler_xyz, quat_mul
+
+from ._types import (
+  Distribution,
+  Operation,
+  resolve_distribution,
+  resolve_operation,
+)
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+Ranges = (
+  tuple[float, float] | dict[int, tuple[float, float]] | dict[str, tuple[float, float]]
+)
+
+_DEFAULT_ASSET_CFG = SceneEntityCfg("robot")
+
+# Mapping from entity_type to the names attribute on Entity / SceneEntityCfg.
+_ENTITY_NAMES_ATTR: dict[str, str] = {
+  "dof": "joint_names",
+  "joint": "joint_names",
+  "body": "body_names",
+  "geom": "geom_names",
+  "site": "site_names",
+  "actuator": "actuator_names",
+  "tendon": "tendon_names",
+  "camera": "camera_names",
+  "light": "light_names",
+  "material": "material_names",
+  "texture": "texture_names",
+  "pair": "pair_names",
+}
+
+# Private engine.
+
+
+def _randomize_model_field(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  field: str,
+  *,
+  entity_type: str,
+  ranges: Ranges,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+  default_axes: list[int] | None = None,
+  valid_axes: list[int] | None = None,
+  use_address: bool = False,
+) -> None:
+  """Core randomization engine for model fields."""
+  operation = resolve_operation(operation)
+  distribution = resolve_distribution(distribution)
+
+  # Handle string-keyed ranges: resolve each pattern and recurse.
+  if isinstance(ranges, dict) and ranges and isinstance(next(iter(ranges)), str):
+    _randomize_with_string_ranges(
+      env,
+      env_ids,
+      field,
+      entity_type=entity_type,
+      ranges=ranges,  # type: ignore[arg-type]
+      distribution=distribution,
+      operation=operation,
+      asset_cfg=asset_cfg,
+      axes=axes,
+      shared_random=shared_random,
+      default_axes=default_axes,
+      valid_axes=valid_axes,
+      use_address=use_address,
+    )
+    return
+
+  # At this point, string-keyed ranges have been handled above.
+  narrowed_ranges: tuple[float, float] | dict[int, tuple[float, float]] = ranges  # type: ignore[assignment]
+
+  asset = env.scene[asset_cfg.name]
+
+  if env_ids is None:
+    env_ids = torch.arange(env.num_envs, device=env.device, dtype=torch.int)
+  else:
+    env_ids = env_ids.to(env.device, dtype=torch.int)
+
+  entity_indices = _get_entity_indices(
+    asset.indexing, asset_cfg, entity_type, use_address
+  )
+
+  model_field = getattr(env.sim.model, field)
+  target_axes = _determine_target_axes(
+    model_field, axes, narrowed_ranges, default_axes, valid_axes
+  )
+  axis_ranges = _prepare_axis_ranges(narrowed_ranges, target_axes, field)
+
+  env_grid, entity_grid = torch.meshgrid(env_ids, entity_indices, indexing="ij")
+  indexed_data = model_field[env_grid, entity_grid]
+
+  if operation.uses_defaults:
+    base_values = _select_default_values(env, field, env_ids, entity_indices)
+  else:
+    base_values = indexed_data
+
+  if shared_random:
+    single_entity_values = base_values[:, :1]
+    random_values = _generate_random_values(
+      distribution,
+      axis_ranges,
+      single_entity_values,
+      target_axes,
+      env.device,
+      operation,
+    )
+    random_values = random_values.expand_as(base_values)
+  else:
+    random_values = _generate_random_values(
+      distribution,
+      axis_ranges,
+      base_values,
+      target_axes,
+      env.device,
+      operation,
+    )
+
+  combined = operation.combine(base_values, random_values)
+
+  # Only write back the axes we targeted. Non-target axes in ``combined`` hold the
+  # operation identity applied to ``base_values`` (e.g. ``default * 1`` for scale),
+  # so writing the full slice would clobber modifications made by earlier events
+  # that targeted different axes of the same field. We loop with an integer axis
+  # index (basic indexing) rather than a device index tensor to avoid a
+  # per-call host-to-device copy; ``target_axes`` is tiny (at most 4).
+  if combined.ndim > 2:
+    for axis in target_axes:
+      model_field[env_grid, entity_grid, axis] = combined[..., axis]
+  else:
+    model_field[env_grid, entity_grid] = combined
+
+
+def _randomize_with_string_ranges(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  field: str,
+  *,
+  entity_type: str,
+  ranges: dict[str, tuple[float, float]],
+  distribution: Distribution | str,
+  operation: Operation | str,
+  asset_cfg: SceneEntityCfg,
+  axes: list[int] | None,
+  shared_random: bool,
+  default_axes: list[int] | None,
+  valid_axes: list[int] | None,
+  use_address: bool,
+) -> None:
+  """Resolve string-keyed ranges to entity names and recurse."""
+  asset: Entity = env.scene[asset_cfg.name]
+  names_attr = _ENTITY_NAMES_ATTR[entity_type]
+  all_names = list(getattr(asset, names_attr))
+
+  for pattern, range_val in ranges.items():
+    matched = [n for n in all_names if re.fullmatch(pattern, n)]
+    if not matched:
+      raise ValueError(
+        f"Pattern '{pattern}' matched no {entity_type} names in "
+        f"entity '{asset_cfg.name}'. Available: {all_names}"
+      )
+    sub_cfg = SceneEntityCfg(asset_cfg.name)
+    setattr(sub_cfg, names_attr, tuple(matched))
+    sub_cfg.resolve(env.scene)
+    _randomize_model_field(
+      env,
+      env_ids,
+      field,
+      entity_type=entity_type,
+      ranges=range_val,
+      distribution=distribution,
+      operation=operation,
+      asset_cfg=sub_cfg,
+      axes=axes,
+      shared_random=shared_random,
+      default_axes=default_axes,
+      valid_axes=valid_axes,
+      use_address=use_address,
+    )
+
+
+def _get_entity_indices(
+  indexing: EntityIndexing,
+  asset_cfg: SceneEntityCfg,
+  entity_type: str,
+  use_address: bool,
+) -> torch.Tensor:
+  match entity_type:
+    case "dof":
+      return indexing.joint_v_adr[asset_cfg.joint_ids]
+    case "joint" if use_address:
+      return indexing.joint_q_adr[asset_cfg.joint_ids]
+    case "joint":
+      return indexing.joint_ids[asset_cfg.joint_ids]
+    case "body":
+      return indexing.body_ids[asset_cfg.body_ids]
+    case "geom":
+      return indexing.geom_ids[asset_cfg.geom_ids]
+    case "site":
+      return indexing.site_ids[asset_cfg.site_ids]
+    case "actuator":
+      assert indexing.ctrl_ids is not None
+      return indexing.ctrl_ids[asset_cfg.actuator_ids]
+    case "tendon":
+      return indexing.tendon_ids[asset_cfg.tendon_ids]
+    case "camera":
+      return indexing.cam_ids[asset_cfg.camera_ids]
+    case "light":
+      return indexing.light_ids[asset_cfg.light_ids]
+    case "material":
+      return indexing.mat_ids[asset_cfg.material_ids]
+    case "texture":
+      return indexing.tex_ids[asset_cfg.texture_ids]
+    case "pair":
+      return indexing.pair_ids[asset_cfg.pair_ids]
+    case _:
+      raise ValueError(f"Unknown entity type: {entity_type}")
+
+
+def _determine_target_axes(
+  model_field: torch.Tensor,
+  axes: list[int] | None,
+  ranges: Ranges,
+  default_axes: list[int] | None,
+  valid_axes: list[int] | None,
+) -> list[int]:
+  """Determine which axes to randomize."""
+  field_ndim = len(model_field.shape) - 1
+
+  if axes is not None:
+    target_axes = axes
+  elif isinstance(ranges, dict) and ranges and isinstance(next(iter(ranges)), int):
+    target_axes = [k for k in ranges if isinstance(k, int)]
+  elif default_axes is not None:
+    target_axes = default_axes
+  else:
+    if field_ndim > 1:
+      target_axes = list(range(model_field.shape[-1]))
+    else:
+      target_axes = [0]
+
+  if valid_axes is not None:
+    invalid_axes = set(target_axes) - set(valid_axes)
+    if invalid_axes:
+      raise ValueError(
+        f"Invalid axes {invalid_axes} for field. Valid axes: {valid_axes}"
+      )
+
+  return target_axes
+
+
+def _prepare_axis_ranges(
+  ranges: tuple[float, float] | dict[int, tuple[float, float]],
+  target_axes: list[int],
+  field: str,
+) -> dict[int, tuple[float, float]]:
+  """Convert ranges to a consistent dictionary format."""
+  if isinstance(ranges, tuple):
+    return {axis: ranges for axis in target_axes}
+  missing_axes = set(target_axes) - set(ranges.keys())
+  if missing_axes:
+    raise ValueError(
+      f"Missing ranges for axes {missing_axes} in field '{field}'. "
+      f"Required axes: {target_axes}"
+    )
+  return {axis: ranges[axis] for axis in target_axes}
+
+
+def _generate_random_values(
+  distribution: Distribution,
+  axis_ranges: dict[int, tuple[float, float]],
+  indexed_data: torch.Tensor,
+  target_axes: list[int],
+  device: str,
+  operation: Operation,
+) -> torch.Tensor:
+  """Generate random values for the specified axes."""
+  result = operation.initialize(indexed_data)
+
+  for axis in target_axes:
+    lower, upper = axis_ranges[axis]
+    lower_bound = torch.tensor([lower], device=device)
+    upper_bound = torch.tensor([upper], device=device)
+
+    if len(indexed_data.shape) > 2:
+      shape = (*indexed_data.shape[:-1], 1)
+    else:
+      shape = indexed_data.shape
+
+    random_vals = distribution.sample(lower_bound, upper_bound, shape, device)
+
+    if len(indexed_data.shape) > 2:
+      result[..., axis] = random_vals.squeeze(-1)
+    else:
+      result = random_vals
+
+  return result
+
+
+# Categorical engine.
+
+
+def _randomize_categorical_field(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  field: str,
+  *,
+  entity_type: str,
+  pool: torch.Tensor,
+  asset_cfg: SceneEntityCfg,
+  shared_random: bool = False,
+  axis: int | None = None,
+) -> None:
+  """Core engine for categorical fields: assign each entry a value from ``pool``."""
+  asset = env.scene[asset_cfg.name]
+
+  if env_ids is None:
+    env_ids = torch.arange(env.num_envs, device=env.device, dtype=torch.int)
+  else:
+    env_ids = env_ids.to(env.device, dtype=torch.int)
+
+  entity_indices = _get_entity_indices(asset.indexing, asset_cfg, entity_type, False)
+  env_grid, entity_grid = torch.meshgrid(env_ids, entity_indices, indexing="ij")
+
+  sample_shape = (env_ids.numel(), 1) if shared_random else env_grid.shape
+  pick = torch.randint(0, int(pool.numel()), sample_shape, device=env.device)
+  pick = pick.expand(env_grid.shape)
+
+  model_field = getattr(env.sim.model, field)
+  if axis is None:
+    model_field[env_grid, entity_grid] = pool[pick]
+  else:
+    model_field[env_grid, entity_grid, axis] = pool[pick]
+
+
+# Quaternion helpers.
+
+
+def _sample_angle(
+  distribution: Distribution | str,
+  range_: tuple[float, float],
+  shape: tuple[int, ...],
+  device: str,
+) -> torch.Tensor:
+  dist = resolve_distribution(distribution)
+  lower = torch.tensor(range_[0], device=device)
+  upper = torch.tensor(range_[1], device=device)
+  return dist.sample(lower, upper, shape, device)
+
+
+def _randomize_quat_field(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  field: str,
+  *,
+  entity_type: str,
+  roll_range: tuple[float, float],
+  pitch_range: tuple[float, float],
+  yaw_range: tuple[float, float],
+  distribution: Distribution | str,
+  asset_cfg: SceneEntityCfg,
+) -> None:
+  """Core implementation for quaternion randomization via RPY composition.
+
+  Composes a sampled RPY perturbation with the default quaternion to
+  produce a valid unit quaternion. Axes with range ``(0.0, 0.0)`` sample
+  zero and leave that rotation component unchanged.
+  """
+  asset = env.scene[asset_cfg.name]
+  if env_ids is None:
+    env_ids = torch.arange(env.num_envs, device=env.device, dtype=torch.int)
+  else:
+    env_ids = env_ids.to(env.device, dtype=torch.int)
+
+  entity_indices = _get_entity_indices(asset.indexing, asset_cfg, entity_type, False)
+  n_envs = len(env_ids)
+  n_entities = len(entity_indices)
+  shape = (n_envs, n_entities)
+
+  roll = _sample_angle(distribution, roll_range, shape, env.device)
+  pitch = _sample_angle(distribution, pitch_range, shape, env.device)
+  yaw = _sample_angle(distribution, yaw_range, shape, env.device)
+
+  # quat_from_euler_xyz requires 1-D inputs; reshape back after.
+  q_perturb = quat_from_euler_xyz(
+    roll.flatten(), pitch.flatten(), yaw.flatten()
+  ).reshape(n_envs, n_entities, 4)
+
+  # Expand default to (n_envs, n_entities, 4) so quat_mul shapes match.
+  q_default_exp = _select_default_values(
+    env, field, env_ids, entity_indices
+  ).contiguous()
+
+  q_new = quat_mul(q_perturb, q_default_exp)  # (n_envs, n_entities, 4)
+
+  model_field = getattr(env.sim.model, field)
+  env_grid, entity_grid = torch.meshgrid(env_ids, entity_indices, indexing="ij")
+  model_field[env_grid, entity_grid] = q_new
+
+
+def _select_default_values(
+  env,
+  field: str,
+  env_ids: torch.Tensor,
+  entity_indices: torch.Tensor,
+) -> torch.Tensor:
+  """Return default model values indexed as ``(env, entity, ...)``.
+
+  Standard model defaults are stored as ``(nentity, ...)`` and are shared by
+  every env. Per-world mesh compilation snapshots variant-dependent defaults as
+  ``(nworld, nentity, ...)`` so downstream DR must preserve each world's variant
+  baseline instead of indexing the first dimension as entities.
+  """
+  default_field = env.sim.get_default_field(field)
+  if field in env.sim.per_world_default_fields:
+    assert default_field.shape[0] == env.num_envs, (
+      f"Field '{field}' is registered as per-world but its default has "
+      f"shape {tuple(default_field.shape)}; expected leading dim "
+      f"{env.num_envs}."
+    )
+    env_grid, entity_grid = torch.meshgrid(env_ids, entity_indices, indexing="ij")
+    return default_field[env_grid, entity_grid]
+
+  values = default_field[entity_indices].unsqueeze(0)
+  return values.expand((env_ids.numel(),) + values.shape[1:])
diff --git a/src/mjlab/envs/mdp/dr/_types.py b/src/mjlab/envs/mdp/dr/_types.py
new file mode 100644
index 0000000..137d114
--- /dev/null
+++ b/src/mjlab/envs/mdp/dr/_types.py
@@ -0,0 +1,165 @@
+"""Extensible Operation and Distribution types for domain randomization."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+import torch
+
+from mjlab.utils.lab_api.math import (
+  sample_gaussian,
+  sample_log_uniform,
+  sample_uniform,
+)
+
+
+@dataclass(frozen=True)
+class Operation:
+  """A domain randomization operation.
+
+  Built-in operations (``abs``, ``scale``, ``add``) are provided as module-level
+  instances. Users can create custom operations by instantiating this class directly
+  and passing them wherever an operation string is accepted.
+
+  The DR engine samples random values for each target axis, then computes::
+
+      combined = operation.combine(base, random)
+
+  and writes back only the targeted axes of ``combined`` (so events targeting
+  different axes of the same field compose instead of clobbering each other).
+  ``base`` is either the compile-time default or the current model value,
+  depending on ``uses_defaults``.
+
+  Args:
+    name: Human-readable identifier (used in error messages).
+    initialize: Called once per randomization call to create the result tensor that
+      gets filled axis by axis with sampled values. Receives the base values and
+      returns a tensor of the same shape. For example, ``scale`` starts from ones so
+      that unsampled axes multiply by 1 (no change), while ``add`` starts from zeros.
+    combine: Called after all axes have been sampled. Receives the base values and the
+      random values and returns the final tensor to write into the model field. For
+      example, ``scale`` returns ``base * random`` and ``add`` returns
+      ``base + random``.
+    uses_defaults: When ``True``, the engine reads the original default field values
+      captured at model compile time (preventing accumulation across repeated calls).
+      When ``False``, the engine reads the current model values instead.
+  """
+
+  name: str
+  initialize: Callable[[torch.Tensor], torch.Tensor]
+  combine: Callable[[torch.Tensor, torch.Tensor], torch.Tensor]
+  uses_defaults: bool
+
+  def __repr__(self) -> str:
+    return f"Operation({self.name!r})"
+
+
+@dataclass(frozen=True)
+class Distribution:
+  """A domain randomization sampling distribution.
+
+  Built-in distributions (``uniform``, ``log_uniform``, ``gaussian``) are provided as
+  module-level instances. Users can create custom distributions by instantiating this
+  class directly.
+
+  Args:
+    name: Human-readable identifier (used in error messages).
+    sample: Called for each target axis. Receives ``(lower, upper, shape, device)`` and
+      returns a tensor of random samples with the given shape on the given device.
+      ``lower`` and ``upper`` come from the ``ranges`` parameter passed to the DR
+      function.
+  """
+
+  name: str
+  sample: Callable[[torch.Tensor, torch.Tensor, tuple[int, ...], str], torch.Tensor]
+
+  def __repr__(self) -> str:
+    return f"Distribution({self.name!r})"
+
+
+# Built-in operations.
+
+abs = Operation(
+  name="abs",
+  initialize=torch.Tensor.clone,
+  combine=lambda base, random: random,
+  uses_defaults=False,
+)
+scale = Operation(
+  name="scale",
+  initialize=torch.ones_like,
+  combine=torch.mul,
+  uses_defaults=True,
+)
+add = Operation(
+  name="add",
+  initialize=torch.zeros_like,
+  combine=torch.add,
+  uses_defaults=True,
+)
+
+# Built-in distributions.
+
+uniform = Distribution(
+  name="uniform",
+  sample=lambda lo, hi, shape, device: sample_uniform(lo, hi, shape, device=device),
+)
+log_uniform = Distribution(
+  name="log_uniform",
+  sample=lambda lo, hi, shape, device: sample_log_uniform(lo, hi, shape, device=device),
+)
+gaussian = Distribution(
+  name="gaussian",
+  sample=lambda lo, hi, shape, device: sample_gaussian(lo, hi, shape, device=device),
+)
+
+# Resolution helpers.
+
+_OPERATION_REGISTRY: dict[str, Operation] = {
+  "abs": abs,
+  "scale": scale,
+  "add": add,
+}
+
+_DISTRIBUTION_REGISTRY: dict[str, Distribution] = {
+  "uniform": uniform,
+  "log_uniform": log_uniform,
+  "gaussian": gaussian,
+}
+
+
+def resolve_operation(op: Operation | str) -> Operation:
+  """Resolve a string or Operation instance to an Operation.
+
+  Raises:
+    ValueError: If the string does not match a built-in operation name.
+  """
+  if isinstance(op, Operation):
+    return op
+  try:
+    return _OPERATION_REGISTRY[op]
+  except KeyError:
+    raise ValueError(
+      f"Unknown operation: {op!r}. "
+      f"Built-in operations: {list(_OPERATION_REGISTRY)}. "
+      f"Pass an Operation instance for custom operations."
+    ) from None
+
+
+def resolve_distribution(dist: Distribution | str) -> Distribution:
+  """Resolve a string or Distribution instance to a Distribution.
+
+  Raises:
+    ValueError: If the string does not match a built-in distribution name.
+  """
+  if isinstance(dist, Distribution):
+    return dist
+  try:
+    return _DISTRIBUTION_REGISTRY[dist]
+  except KeyError:
+    raise ValueError(
+      f"Unknown distribution: {dist!r}. "
+      f"Built-in distributions: {list(_DISTRIBUTION_REGISTRY)}. "
+      f"Pass a Distribution instance for custom distributions."
+    ) from None
diff --git a/src/mjlab/envs/mdp/dr/actuator.py b/src/mjlab/envs/mdp/dr/actuator.py
new file mode 100644
index 0000000..09c0546
--- /dev/null
+++ b/src/mjlab/envs/mdp/dr/actuator.py
@@ -0,0 +1,307 @@
+"""Domain randomization functions for actuators."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+import torch
+
+from mjlab.actuator import (
+  BuiltinDcMotorActuator,
+  BuiltinPdActuator,
+  BuiltinPositionActuator,
+  IdealPdActuator,
+)
+from mjlab.actuator.actuator import TransmissionType
+from mjlab.actuator.builtin_actuator import DcMotorInputMode
+from mjlab.actuator.xml_actuator import XmlActuator
+from mjlab.entity import Entity
+from mjlab.managers.event_manager import requires_model_fields
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+from ._core import _DEFAULT_ASSET_CFG
+from ._types import Operation, resolve_distribution, resolve_operation
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+@requires_model_fields("actuator_gainprm", "actuator_biasprm")
+def pd_gains(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  kp_range: tuple[float, float],
+  kd_range: tuple[float, float],
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Literal["uniform", "log_uniform"] = "uniform",
+  operation: Operation | str = "scale",
+) -> None:
+  """Randomize PD stiffness and damping gains.
+
+  Args:
+    env: The environment.
+    env_ids: Environment IDs to randomize. If None, randomizes all.
+    kp_range: (min, max) for proportional gain randomization.
+    kd_range: (min, max) for derivative gain randomization.
+    asset_cfg: Asset configuration specifying which entity and actuators.
+    distribution: Distribution type ("uniform" or "log_uniform").
+    operation: "scale" multiplies default gains by sampled values, "abs" sets
+      absolute values.
+  """
+  op = resolve_operation(operation)
+  if op.name not in ("scale", "abs"):
+    raise ValueError(
+      f"pd_gains only supports 'scale' and 'abs' operations, got {op.name!r}"
+    )
+  asset: Entity = env.scene[asset_cfg.name]
+
+  if env_ids is None:
+    env_ids = torch.arange(env.num_envs, device=env.device, dtype=torch.int)
+  else:
+    env_ids = env_ids.to(env.device, dtype=torch.int)
+
+  if isinstance(asset_cfg.actuator_ids, list):
+    actuators = [asset.actuators[i] for i in asset_cfg.actuator_ids]
+  elif isinstance(asset_cfg.actuator_ids, slice):
+    actuators = asset.actuators[asset_cfg.actuator_ids]
+  else:
+    actuators = [asset.actuators[asset_cfg.actuator_ids]]
+
+  for actuator in actuators:
+    ctrl_ids = actuator.global_ctrl_ids
+    # Each target needs one kp draw and one kd draw. For single-element
+    # actuators that's len(ctrl_ids) of each; for BuiltinPd the ctrl tensor
+    # has 2*N entries but only N independent kp/kd values, so we sample
+    # num_targets to avoid throwing the other half away.
+    n_gains = (
+      actuator.num_targets if isinstance(actuator, BuiltinPdActuator) else len(ctrl_ids)
+    )
+
+    dist = resolve_distribution(distribution)
+    kp_samples = dist.sample(
+      torch.tensor(kp_range[0], device=env.device),
+      torch.tensor(kp_range[1], device=env.device),
+      (len(env_ids), n_gains),
+      env.device,
+    )
+    kd_samples = dist.sample(
+      torch.tensor(kd_range[0], device=env.device),
+      torch.tensor(kd_range[1], device=env.device),
+      (len(env_ids), n_gains),
+      env.device,
+    )
+
+    if isinstance(actuator, BuiltinPositionActuator) or (
+      isinstance(actuator, XmlActuator) and actuator.command_field == "position"
+    ):
+      if op.name == "scale":
+        default_gainprm = env.sim.get_default_field("actuator_gainprm")
+        default_biasprm = env.sim.get_default_field("actuator_biasprm")
+        env.sim.model.actuator_gainprm[env_ids[:, None], ctrl_ids, 0] = (
+          default_gainprm[ctrl_ids, 0] * kp_samples
+        )
+        env.sim.model.actuator_biasprm[env_ids[:, None], ctrl_ids, 1] = (
+          default_biasprm[ctrl_ids, 1] * kp_samples
+        )
+        env.sim.model.actuator_biasprm[env_ids[:, None], ctrl_ids, 2] = (
+          default_biasprm[ctrl_ids, 2] * kd_samples
+        )
+      else:
+        assert op.name == "abs"
+        env.sim.model.actuator_gainprm[env_ids[:, None], ctrl_ids, 0] = kp_samples
+        env.sim.model.actuator_biasprm[env_ids[:, None], ctrl_ids, 1] = -kp_samples
+        env.sim.model.actuator_biasprm[env_ids[:, None], ctrl_ids, 2] = -kd_samples
+
+    elif isinstance(actuator, BuiltinDcMotorActuator):
+      if actuator.cfg.mode == DcMotorInputMode.VOLTAGE:
+        raise ValueError(
+          "dr.pd_gains does not apply to BuiltinDcMotorActuator in VOLTAGE "
+          "mode (no internal PID gains to scale)."
+        )
+      # DC motor stores kp at gainprm[4] and kd at gainprm[6] (set via
+      # set_to_dcmotor). The bias slots carry back-EMF / cogging, not the PD,
+      # so we only touch gainprm.
+      if op.name == "scale":
+        default_gainprm = env.sim.get_default_field("actuator_gainprm")
+        env.sim.model.actuator_gainprm[env_ids[:, None], ctrl_ids, 4] = (
+          default_gainprm[ctrl_ids, 4] * kp_samples
+        )
+        env.sim.model.actuator_gainprm[env_ids[:, None], ctrl_ids, 6] = (
+          default_gainprm[ctrl_ids, 6] * kd_samples
+        )
+      else:
+        assert op.name == "abs"
+        env.sim.model.actuator_gainprm[env_ids[:, None], ctrl_ids, 4] = kp_samples
+        env.sim.model.actuator_gainprm[env_ids[:, None], ctrl_ids, 6] = kd_samples
+
+    elif isinstance(actuator, BuiltinPdActuator):
+      # ctrl_ids is laid out as [pos_0..pos_{N-1}, vel_0..vel_{N-1}], so the
+      # first N rows carry kp and the next N carry kd.
+      n = actuator.num_targets
+      pos_ids = ctrl_ids[:n]
+      vel_ids = ctrl_ids[n:]
+      if op.name == "scale":
+        default_gainprm = env.sim.get_default_field("actuator_gainprm")
+        default_biasprm = env.sim.get_default_field("actuator_biasprm")
+        env.sim.model.actuator_gainprm[env_ids[:, None], pos_ids, 0] = (
+          default_gainprm[pos_ids, 0] * kp_samples
+        )
+        env.sim.model.actuator_biasprm[env_ids[:, None], pos_ids, 1] = (
+          default_biasprm[pos_ids, 1] * kp_samples
+        )
+        env.sim.model.actuator_gainprm[env_ids[:, None], vel_ids, 0] = (
+          default_gainprm[vel_ids, 0] * kd_samples
+        )
+        env.sim.model.actuator_biasprm[env_ids[:, None], vel_ids, 2] = (
+          default_biasprm[vel_ids, 2] * kd_samples
+        )
+      else:
+        assert op.name == "abs"
+        env.sim.model.actuator_gainprm[env_ids[:, None], pos_ids, 0] = kp_samples
+        env.sim.model.actuator_biasprm[env_ids[:, None], pos_ids, 1] = -kp_samples
+        env.sim.model.actuator_gainprm[env_ids[:, None], vel_ids, 0] = kd_samples
+        env.sim.model.actuator_biasprm[env_ids[:, None], vel_ids, 2] = -kd_samples
+      # biasprm[2] on the position half stays zero by construction. Writing
+      # anything else here would inject damping into the position element on
+      # top of the velocity element, silently double-counting kd.
+
+    elif isinstance(actuator, IdealPdActuator):
+      assert actuator.stiffness is not None
+      assert actuator.damping is not None
+      if op.name == "scale":
+        assert actuator.default_stiffness is not None
+        assert actuator.default_damping is not None
+        actuator.set_gains(
+          env_ids,
+          kp=actuator.default_stiffness[env_ids] * kp_samples,
+          kd=actuator.default_damping[env_ids] * kd_samples,
+        )
+      else:
+        assert op.name == "abs"
+        actuator.set_gains(env_ids, kp=kp_samples, kd=kd_samples)
+
+    else:
+      raise TypeError(
+        f"pd_gains only supports BuiltinPositionActuator, BuiltinPdActuator, "
+        f"BuiltinDcMotorActuator (position/velocity mode), XmlActuator (position), "
+        f"and IdealPdActuator, got {type(actuator).__name__}"
+      )
+
+
+@requires_model_fields("actuator_forcerange", "jnt_actfrcrange", "tendon_actfrcrange")
+def effort_limits(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  effort_limit_range: tuple[float, float],
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Literal["uniform", "log_uniform"] = "uniform",
+  operation: Operation | str = "scale",
+) -> None:
+  """Randomize actuator effort limits.
+
+  Args:
+    env: The environment.
+    env_ids: Environment IDs to randomize. If None, randomizes all.
+    effort_limit_range: (min, max) for effort limit randomization.
+    asset_cfg: Asset configuration specifying which entity and actuators.
+    distribution: Distribution type ("uniform" or "log_uniform").
+    operation: "scale" multiplies default limits, "abs" sets absolute values.
+  """
+  op = resolve_operation(operation)
+  if op.name not in ("scale", "abs"):
+    raise ValueError(
+      f"effort_limits only supports 'scale' and 'abs' operations, got {op.name!r}"
+    )
+  asset: Entity = env.scene[asset_cfg.name]
+
+  if env_ids is None:
+    env_ids = torch.arange(env.num_envs, device=env.device, dtype=torch.int)
+  else:
+    env_ids = env_ids.to(env.device, dtype=torch.int)
+
+  if isinstance(asset_cfg.actuator_ids, list):
+    actuators = [asset.actuators[i] for i in asset_cfg.actuator_ids]
+  else:
+    actuators = asset.actuators[asset_cfg.actuator_ids]
+
+  if not isinstance(actuators, list):
+    actuators = [actuators]
+
+  for actuator in actuators:
+    ctrl_ids = actuator.global_ctrl_ids
+    # One effort sample per target. For single-element actuators this matches
+    # ctrl_ids; for BuiltinPd the limit lives on the joint/tendon, so one
+    # sample per target is sufficient regardless of the two-element ctrl.
+    n_samples = (
+      actuator.num_targets if isinstance(actuator, BuiltinPdActuator) else len(ctrl_ids)
+    )
+
+    dist = resolve_distribution(distribution)
+    effort_samples = dist.sample(
+      torch.tensor(effort_limit_range[0], device=env.device),
+      torch.tensor(effort_limit_range[1], device=env.device),
+      (len(env_ids), n_samples),
+      env.device,
+    )
+
+    if isinstance(actuator, (BuiltinPositionActuator, BuiltinDcMotorActuator)) or (
+      isinstance(actuator, XmlActuator) and actuator.command_field == "position"
+    ):
+      if op.name == "scale":
+        default_forcerange = env.sim.get_default_field("actuator_forcerange")
+        env.sim.model.actuator_forcerange[env_ids[:, None], ctrl_ids, 0] = (
+          default_forcerange[ctrl_ids, 0] * effort_samples
+        )
+        env.sim.model.actuator_forcerange[env_ids[:, None], ctrl_ids, 1] = (
+          default_forcerange[ctrl_ids, 1] * effort_samples
+        )
+      else:
+        assert op.name == "abs"
+        env.sim.model.actuator_forcerange[
+          env_ids[:, None], ctrl_ids, 0
+        ] = -effort_samples
+        env.sim.model.actuator_forcerange[env_ids[:, None], ctrl_ids, 1] = (
+          effort_samples
+        )
+
+    elif isinstance(actuator, IdealPdActuator):
+      assert actuator.force_limit is not None
+      if op.name == "scale":
+        assert actuator.default_force_limit is not None
+        actuator.set_effort_limit(
+          env_ids,
+          effort_limit=actuator.default_force_limit[env_ids] * effort_samples,
+        )
+      else:
+        assert op.name == "abs"
+        actuator.set_effort_limit(env_ids, effort_limit=effort_samples)
+
+    elif isinstance(actuator, BuiltinPdActuator):
+      # BuiltinPd's effort_limit lives on the joint/tendon as a sum-clamp
+      # (jnt_actfrcrange / tendon_actfrcrange), not on per-element forcerange.
+      if actuator.transmission_type == TransmissionType.JOINT:
+        field = "jnt_actfrcrange"
+        target_global_ids = asset.indexing.joint_ids[actuator.target_ids]
+      else:
+        field = "tendon_actfrcrange"
+        target_global_ids = asset.indexing.tendon_ids[actuator.target_ids]
+      arr = getattr(env.sim.model, field)
+      if op.name == "scale":
+        default = env.sim.get_default_field(field)
+        arr[env_ids[:, None], target_global_ids, 0] = (
+          default[target_global_ids, 0] * effort_samples
+        )
+        arr[env_ids[:, None], target_global_ids, 1] = (
+          default[target_global_ids, 1] * effort_samples
+        )
+      else:
+        assert op.name == "abs"
+        arr[env_ids[:, None], target_global_ids, 0] = -effort_samples
+        arr[env_ids[:, None], target_global_ids, 1] = effort_samples
+
+    else:
+      raise TypeError(
+        f"effort_limits only supports BuiltinPositionActuator, BuiltinPdActuator, "
+        f"BuiltinDcMotorActuator, XmlActuator (position), and IdealPdActuator, "
+        f"got {type(actuator).__name__}"
+      )
diff --git a/src/mjlab/envs/mdp/dr/body.py b/src/mjlab/envs/mdp/dr/body.py
new file mode 100644
index 0000000..8dc0eaa
--- /dev/null
+++ b/src/mjlab/envs/mdp/dr/body.py
@@ -0,0 +1,541 @@
+"""Domain randomization functions for body fields."""
+
+from __future__ import annotations
+
+import warnings
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.managers.event_manager import RecomputeLevel, requires_model_fields
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.utils.lab_api.math import (
+  matrix_from_quat,
+  quat_from_matrix,
+)
+
+from ._core import (
+  _DEFAULT_ASSET_CFG,
+  Ranges,
+  _get_entity_indices,
+  _randomize_model_field,
+  _randomize_quat_field,
+  _sample_angle,
+  _select_default_values,
+)
+from ._types import Distribution, Operation
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+# Number of Jacobi sweeps for 3x3 eigendecomposition. Each sweep applies 3 Givens
+# rotations (one per off-diagonal pair). 5 sweeps are more than enough for 3x3 matrices
+# to converge to machine precision.
+_JACOBI_SWEEPS = 5
+
+# Pseudo-inertia helpers.
+
+
+def _cholesky_4x4(A: torch.Tensor) -> torch.Tensor:
+  """Analytical Cholesky for batched 4x4 SPD matrices.
+
+  Avoids ``torch.linalg.cholesky`` (and the cuSOLVER library it loads), which allocates
+  several GB of persistent GPU memory on first use.
+
+  Args:
+    A: ``(*batch, 4, 4)`` symmetric positive-definite matrix.
+
+  Returns:
+    L: ``(*batch, 4, 4)`` lower-triangular Cholesky factor.
+  """
+  L = torch.zeros_like(A)
+  L[..., 0, 0] = torch.sqrt(A[..., 0, 0])
+  L[..., 1, 0] = A[..., 1, 0] / L[..., 0, 0]
+  L[..., 2, 0] = A[..., 2, 0] / L[..., 0, 0]
+  L[..., 3, 0] = A[..., 3, 0] / L[..., 0, 0]
+  L[..., 1, 1] = torch.sqrt(A[..., 1, 1] - L[..., 1, 0] ** 2)
+  L[..., 2, 1] = (A[..., 2, 1] - L[..., 2, 0] * L[..., 1, 0]) / L[..., 1, 1]
+  L[..., 3, 1] = (A[..., 3, 1] - L[..., 3, 0] * L[..., 1, 0]) / L[..., 1, 1]
+  L[..., 2, 2] = torch.sqrt(A[..., 2, 2] - L[..., 2, 0] ** 2 - L[..., 2, 1] ** 2)
+  L[..., 3, 2] = (
+    A[..., 3, 2] - L[..., 3, 0] * L[..., 2, 0] - L[..., 3, 1] * L[..., 2, 1]
+  ) / L[..., 2, 2]
+  L[..., 3, 3] = torch.sqrt(
+    A[..., 3, 3] - L[..., 3, 0] ** 2 - L[..., 3, 1] ** 2 - L[..., 3, 2] ** 2
+  )
+  return L
+
+
+def _eigh_3x3_jacobi(
+  A: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor]:
+  """Batched eigendecomposition for 3x3 symmetric matrices via Jacobi.
+
+  Avoids ``torch.linalg.eigh`` (and the cuSOLVER library it loads), which allocates
+  several GB of persistent GPU memory on first use.
+
+  Uses cyclic Jacobi rotations over the three off-diagonal pairs. For 3x3 matrices,
+  ``_JACOBI_SWEEPS`` sweeps converge to machine precision.
+
+  Args:
+    A: ``(*batch, 3, 3)`` symmetric matrix.
+
+  Returns:
+    eigenvalues: ``(*batch, 3)`` in ascending order.
+    V: ``(*batch, 3, 3)`` orthogonal eigenvectors (columns).
+  """
+  D = A.clone()
+  V = torch.eye(3, device=A.device, dtype=A.dtype).expand_as(D).clone()
+
+  for _ in range(_JACOBI_SWEEPS):
+    for p, q in ((0, 1), (0, 2), (1, 2)):
+      r = 3 - p - q
+      apq = D[..., p, q]
+      app = D[..., p, p]
+      aqq = D[..., q, q]
+
+      # Jacobi rotation: tau = (aqq - app) / (2*apq),
+      # t = sign(tau) / (|tau| + sqrt(1 + tau^2)).
+      diff = aqq - app
+      denom = 2 * apq
+      tau = diff / denom
+      t = torch.sign(tau) / (torch.abs(tau) + torch.sqrt(1 + tau * tau))
+      # When apq ≈ 0, skip rotation (t = 0).
+      t = torch.where(torch.abs(denom) > 1e-30, t, torch.zeros_like(t))
+
+      c = 1 / torch.sqrt(1 + t * t)
+      s = t * c
+
+      # Update diagonal and off-diagonal elements.
+      D[..., p, p] = app - t * apq
+      D[..., q, q] = aqq + t * apq
+      D[..., p, q] = D[..., q, p] = 0
+
+      arp = D[..., r, p].clone()
+      arq = D[..., r, q].clone()
+      D[..., r, p] = D[..., p, r] = c * arp - s * arq
+      D[..., r, q] = D[..., q, r] = s * arp + c * arq
+
+      # Accumulate eigenvectors: V[:, p/q] = c*Vp ∓ s*Vq.
+      vp = V[..., :, p].clone()
+      vq = V[..., :, q].clone()
+      c_exp = c.unsqueeze(-1)
+      s_exp = s.unsqueeze(-1)
+      V[..., :, p] = c_exp * vp - s_exp * vq
+      V[..., :, q] = s_exp * vp + c_exp * vq
+
+  eigenvalues = torch.stack([D[..., 0, 0], D[..., 1, 1], D[..., 2, 2]], dim=-1)
+
+  # Sort in ascending order to match torch.linalg.eigh convention.
+  idx = eigenvalues.argsort(dim=-1)
+  eigenvalues = eigenvalues.gather(-1, idx)
+  V = V.gather(-1, idx.unsqueeze(-2).expand_as(V))
+
+  return eigenvalues, V
+
+
+def _reconstruct_pseudo_inertia_J(
+  mass: torch.Tensor,
+  ipos: torch.Tensor,
+  inertia: torch.Tensor,
+  iquat: torch.Tensor,
+) -> torch.Tensor:
+  """Build the 4x4 pseudo-inertia matrix J from MuJoCo body fields.
+
+  1. Rotate principal moments into body frame via ``body_iquat``.
+  2. Apply the parallel-axis theorem to shift inertia from COM to body origin.
+
+  Args:
+    mass: ``(*batch,)``.
+    ipos: COM in body frame, ``(*batch, 3)``.
+    inertia: Principal moments, ``(*batch, 3)``.
+    iquat: Principal-to-body quaternion (wxyz), ``(*batch, 4)``.
+
+  Returns:
+    J: ``(*batch, 4, 4)``.
+  """
+  I3 = torch.eye(3, device=mass.device, dtype=mass.dtype)
+
+  # Rotate principal moments into body frame (body_iquat maps principal->body).
+  R = matrix_from_quat(iquat)  # (*batch, 3, 3)
+  I_com = R @ torch.diag_embed(inertia) @ R.mT  # (*batch, 3, 3)
+
+  # Parallel-axis theorem: shift inertia from COM to body origin.
+  c = ipos
+  c_sq = (c * c).sum(dim=-1)  # (*batch,)
+  c_outer = c.unsqueeze(-1) * c.unsqueeze(-2)  # (*batch, 3, 3)
+  m = mass.unsqueeze(-1).unsqueeze(-1)  # (*batch, 1, 1)
+  I_origin = I_com + m * (
+    c_sq.unsqueeze(-1).unsqueeze(-1) * I3 - c_outer
+  )  # (*batch, 3, 3)
+
+  # sigma = 0.5 * Tr(I_origin) * I3 - I_origin
+  trace = I_origin.diagonal(dim1=-2, dim2=-1).sum(dim=-1)  # (*batch,)
+  sigma = 0.5 * trace.unsqueeze(-1).unsqueeze(-1) * I3 - I_origin
+
+  h = mass.unsqueeze(-1) * ipos  # first mass moment
+
+  batch_shape = mass.shape
+  J = torch.zeros(*batch_shape, 4, 4, device=mass.device, dtype=mass.dtype)
+  J[..., :3, :3] = sigma
+  J[..., :3, 3] = h
+  J[..., 3, :3] = h
+  J[..., 3, 3] = mass
+  return J
+
+
+def _decompose_pseudo_inertia_J(
+  J: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+  """Decompose pseudo-inertia matrix to MuJoCo body fields (exact).
+
+  Extracts ``body_mass``, ``body_ipos``, ``body_inertia`` (principal moments), and
+  ``body_iquat`` (principal-frame rotation) by diagonalizing the full inertia tensor
+  via eigendecomposition. This is exact for any perturbation magnitude, including large
+  shear.
+
+  Args:
+    J: 4x4 pseudo-inertia matrix, shape ``(*batch, 4, 4)``.
+
+  Returns:
+    Tuple of (mass, ipos, inertia, iquat) with shapes ``(*batch,)``,
+    ``(*batch, 3)``, ``(*batch, 3)``, ``(*batch, 4)``.
+  """
+  mass = J[..., 3, 3]
+  h = J[..., :3, 3]
+  ipos = h / mass.unsqueeze(-1)
+
+  sigma = J[..., :3, :3]
+  trace_sigma = sigma.diagonal(dim1=-2, dim2=-1).sum(dim=-1)  # (*batch,)
+  I3 = torch.eye(3, device=J.device, dtype=J.dtype)
+  # Invert sigma = 0.5*Tr(I)*I3 - I  =>  I_origin = Tr(sigma)*I3 - sigma
+  I_origin = trace_sigma.unsqueeze(-1).unsqueeze(-1) * I3 - sigma  # (*batch, 3, 3)
+
+  # Inverse parallel-axis: shift inertia from body origin back to COM.
+  c = ipos
+  c_sq = (c * c).sum(dim=-1)  # (*batch,)
+  c_outer = c.unsqueeze(-1) * c.unsqueeze(-2)  # (*batch, 3, 3)
+  m = mass.unsqueeze(-1).unsqueeze(-1)  # (*batch, 1, 1)
+  I_com = I_origin - m * (
+    c_sq.unsqueeze(-1).unsqueeze(-1) * I3 - c_outer
+  )  # (*batch, 3, 3)
+
+  # Columns of V are principal axes in body frame; eigenvalues are principal moments.
+  principal_moments, V = _eigh_3x3_jacobi(I_com)
+
+  # Ensure V is a proper rotation (det = +1). eigh can return reflections.
+  dets = torch.linalg.det(V)  # (*batch,)
+  neg = dets < 0
+  if torch.any(neg):
+    V = V.clone()
+    V[neg, :, 2] *= -1
+
+  # MuJoCo body_iquat is principal->body, i.e. it represents R = V.
+  iquat = quat_from_matrix(V)  # (*batch, 4), wxyz
+
+  return mass, ipos, principal_moments, iquat
+
+
+def _build_perturbation_U(
+  alpha: torch.Tensor,
+  d1: torch.Tensor,
+  d2: torch.Tensor,
+  d3: torch.Tensor,
+  s12: torch.Tensor,
+  s13: torch.Tensor,
+  s23: torch.Tensor,
+  t1: torch.Tensor,
+  t2: torch.Tensor,
+  t3: torch.Tensor,
+) -> torch.Tensor:
+  """Build the upper-triangular perturbation matrix U from 10 parameters.
+
+  .. code-block::
+
+      U = e^alpha * [[e^d1, s12, s13, t1],
+                  [0,   e^d2, s23, t2],
+                  [0,   0,   e^d3, t3],
+                  [0,   0,   0,    1 ]]
+
+  All arguments have shape ``(*batch,)``.
+
+  Returns:
+    U: shape ``(*batch, 4, 4)``.
+  """
+  scale = torch.exp(alpha)  # (*batch,)
+  batch_shape = alpha.shape
+  U = torch.zeros(*batch_shape, 4, 4, device=alpha.device, dtype=alpha.dtype)
+  U[..., 0, 0] = scale * torch.exp(d1)
+  U[..., 0, 1] = scale * s12
+  U[..., 0, 2] = scale * s13
+  U[..., 0, 3] = scale * t1
+  U[..., 1, 1] = scale * torch.exp(d2)
+  U[..., 1, 2] = scale * s23
+  U[..., 1, 3] = scale * t2
+  U[..., 2, 2] = scale * torch.exp(d3)
+  U[..., 2, 3] = scale * t3
+  U[..., 3, 3] = scale  # e^alpha × 1
+  return U
+
+
+# Per-field functions.
+
+
+@requires_model_fields("body_mass", recompute=RecomputeLevel.set_const)
+def body_mass(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "scale",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize body mass. Triggers ``set_const`` recomputation.
+
+  .. warning::
+
+    This function only changes ``body_mass`` and leaves ``body_inertia``
+    unchanged. For a uniform density change (the typical DR use case),
+    inertia should scale proportionally with mass. Use
+    :func:`pseudo_inertia` with ``alpha_range`` instead, which scales both
+    correctly. ``body_mass`` alone is only appropriate when modelling a
+    point mass added at the COM (which contributes zero inertia).
+  """
+  warnings.warn(
+    "dr.body_mass only randomizes mass and leaves the inertia tensor "
+    "unchanged. For a physically consistent density change, use "
+    "dr.pseudo_inertia(alpha_range=...) instead, which scales both mass "
+    "and inertia together. dr.body_mass is only appropriate when modelling "
+    "a point mass added at the COM.",
+    UserWarning,
+    stacklevel=2,
+  )
+  _randomize_model_field(
+    env,
+    env_ids,
+    "body_mass",
+    entity_type="body",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+  )
+
+
+@requires_model_fields("body_ipos", recompute=RecomputeLevel.set_const)
+def body_com_offset(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "add",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize body COM offset (body_ipos). Triggers ``set_const``."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "body_ipos",
+    entity_type="body",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0, 1, 2],
+  )
+
+
+# Raw alias.
+body_ipos = body_com_offset
+
+
+@requires_model_fields("body_pos", recompute=RecomputeLevel.set_const_0)
+def body_pos(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "add",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize body position. Triggers ``set_const_0``."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "body_pos",
+    entity_type="body",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0, 1, 2],
+  )
+
+
+@requires_model_fields("body_quat", recompute=RecomputeLevel.set_const_0)
+def body_quat(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  roll_range: tuple[float, float] = (0.0, 0.0),
+  pitch_range: tuple[float, float] = (0.0, 0.0),
+  yaw_range: tuple[float, float] = (0.0, 0.0),
+  distribution: Distribution | str = "uniform",
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> None:
+  """Randomize body orientation by composing an RPY perturbation.
+
+  Ranges are in radians. The sampled perturbation is composed with the default
+  quaternion (not the current one), so repeated calls do not accumulate. The result is
+  always a valid unit quaternion. Triggers ``set_const_0`` recomputation.
+  """
+  _randomize_quat_field(
+    env,
+    env_ids,
+    "body_quat",
+    entity_type="body",
+    roll_range=roll_range,
+    pitch_range=pitch_range,
+    yaw_range=yaw_range,
+    distribution=distribution,
+    asset_cfg=asset_cfg,
+  )
+
+
+@requires_model_fields(
+  "body_mass",
+  "body_ipos",
+  "body_inertia",
+  "body_iquat",
+  recompute=RecomputeLevel.set_const,
+)
+def pseudo_inertia(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  alpha_range: tuple[float, float] = (0.0, 0.0),
+  d_range: tuple[float, float] | None = None,
+  d1_range: tuple[float, float] = (0.0, 0.0),
+  d2_range: tuple[float, float] = (0.0, 0.0),
+  d3_range: tuple[float, float] = (0.0, 0.0),
+  s12_range: tuple[float, float] = (0.0, 0.0),
+  s13_range: tuple[float, float] = (0.0, 0.0),
+  s23_range: tuple[float, float] = (0.0, 0.0),
+  t_range: tuple[float, float] | None = None,
+  t1_range: tuple[float, float] = (0.0, 0.0),
+  t2_range: tuple[float, float] = (0.0, 0.0),
+  t3_range: tuple[float, float] = (0.0, 0.0),
+  distribution: Distribution | str = "uniform",
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> None:
+  r"""Physics-consistent inertial randomization via the pseudo-inertia matrix.
+
+  Jointly randomizes ``body_mass``, ``body_ipos``, ``body_inertia``, and ``body_iquat``
+  while guaranteeing exact physical consistency for any perturbation magnitude.
+  Triggers ``set_const`` recomputation.
+
+  The parameterization follows `Rucker & Wensing, 2022
+  <https://par.nsf.gov/servlets/purl/10347458>`_: the pseudo-inertia matrix
+  :math:`J \succ 0` is factored via
+  Cholesky as :math:`J = LL^\top`, then perturbed by an upper-triangular matrix
+  U: :math:`J' = (UL)(UL)^\top`. The result is diagonalized via eigendecomposition to
+  extract principal moments (``body_inertia``) and principal frame rotation
+  (``body_iquat``), so it is exact for any perturbation magnitude.
+
+  The 10 parameters and their physical effects:
+
+  - ``alpha``: global mass-density scale — mass and inertia scale by
+    :math:`e^{2\alpha}`, COM unchanged.
+  - ``d1, d2, d3``: axis-aligned stretch/compress. Use ``d_range`` as a convenience to
+    set all three to the same range.
+  - ``s12, s13, s23``: shear in the xy, xz, and yz planes.
+  - ``t1, t2, t3``: COM shift along x, y, z axes (in body frame). Use ``t_range`` as a
+    convenience to set all three to the same range.
+
+  Args:
+    env: The RL environment.
+    env_ids: Environment indices to randomize. If ``None``, all envs.
+    alpha_range: Range for global mass-density log-scale.
+    d_range: Convenience shorthand — sets ``d1_range=d2_range=d3_range``.
+    d1_range: Stretch/compress along the x axis.
+    d2_range: Stretch/compress along the y axis.
+    d3_range: Stretch/compress along the z axis.
+    s12_range: Shear in the xy plane.
+    s13_range: Shear in the xz plane.
+    s23_range: Shear in the yz plane.
+    t_range: Convenience shorthand — sets ``t1_range=t2_range=t3_range``.
+    t1_range: COM shift along the x axis (body frame).
+    t2_range: COM shift along the y axis (body frame).
+    t3_range: COM shift along the z axis (body frame).
+    distribution: Sampling distribution for all parameters.
+    asset_cfg: Asset and body selection.
+  """
+  if d_range is not None:
+    d1_range = d2_range = d3_range = d_range
+  if t_range is not None:
+    t1_range = t2_range = t3_range = t_range
+
+  asset = env.scene[asset_cfg.name]
+  if env_ids is None:
+    env_ids = torch.arange(env.num_envs, device=env.device, dtype=torch.int)
+  else:
+    env_ids = env_ids.to(env.device, dtype=torch.int)
+
+  entity_indices = _get_entity_indices(asset.indexing, asset_cfg, "body", False)
+  n_envs = len(env_ids)
+  n_bodies = len(entity_indices)
+  shape = (n_envs, n_bodies)
+
+  def_mass = _select_default_values(env, "body_mass", env_ids, entity_indices)
+  def_ipos = _select_default_values(env, "body_ipos", env_ids, entity_indices)
+  def_inertia = _select_default_values(env, "body_inertia", env_ids, entity_indices)
+  def_iquat = _select_default_values(env, "body_iquat", env_ids, entity_indices)
+
+  # Reconstruct J_default for each env/body: (n_envs, n_bodies, 4, 4).
+  J_default = _reconstruct_pseudo_inertia_J(def_mass, def_ipos, def_inertia, def_iquat)
+
+  # Cholesky factor L: (n_envs, n_bodies, 4, 4), lower triangular.
+  L = _cholesky_4x4(J_default)
+
+  # Sample perturbation parameters, each (n_envs, n_bodies).
+  def sample(r: tuple[float, float]) -> torch.Tensor:
+    return _sample_angle(distribution, r, shape, env.device)
+
+  alpha = sample(alpha_range)
+  d1 = sample(d1_range)
+  d2 = sample(d2_range)
+  d3 = sample(d3_range)
+  s12 = sample(s12_range)
+  s13 = sample(s13_range)
+  s23 = sample(s23_range)
+  t1 = sample(t1_range)
+  t2 = sample(t2_range)
+  t3 = sample(t3_range)
+
+  # Build U: (n_envs, n_bodies, 4, 4), upper triangular.
+  U = _build_perturbation_U(alpha, d1, d2, d3, s12, s13, s23, t1, t2, t3)
+
+  # L_new = U @ L.
+  L_new = torch.matmul(U, L)  # (n_envs, n_bodies, 4, 4)
+
+  # New pseudo-inertia: J' = L_new @ L_newᵀ.
+  J_new = torch.matmul(L_new, L_new.mT)  # (n_envs, n_bodies, 4, 4)
+
+  # Decompose back to MuJoCo fields via eigendecomposition (exact).
+  mass_new, ipos_new, inertia_new, iquat_new = _decompose_pseudo_inertia_J(J_new)
+
+  env_grid, entity_grid = torch.meshgrid(env_ids, entity_indices, indexing="ij")
+  env.sim.model.body_mass[env_grid, entity_grid] = mass_new
+  env.sim.model.body_ipos[env_grid, entity_grid] = ipos_new
+  env.sim.model.body_inertia[env_grid, entity_grid] = inertia_new
+  env.sim.model.body_iquat[env_grid, entity_grid] = iquat_new
diff --git a/src/mjlab/envs/mdp/dr/camera.py b/src/mjlab/envs/mdp/dr/camera.py
new file mode 100644
index 0000000..69bcb32
--- /dev/null
+++ b/src/mjlab/envs/mdp/dr/camera.py
@@ -0,0 +1,130 @@
+"""Domain randomization functions for camera fields."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.managers.event_manager import requires_model_fields
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+from ._core import (
+  _DEFAULT_ASSET_CFG,
+  Ranges,
+  _randomize_model_field,
+  _randomize_quat_field,
+)
+from ._types import Distribution, Operation
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+@requires_model_fields("cam_fovy")
+def cam_fovy(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize camera field-of-view (vertical, degrees)."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "cam_fovy",
+    entity_type="camera",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+  )
+
+
+@requires_model_fields("cam_pos")
+def cam_pos(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize camera positions."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "cam_pos",
+    entity_type="camera",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0, 1, 2],
+  )
+
+
+@requires_model_fields("cam_quat")
+def cam_quat(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  roll_range: tuple[float, float] = (0.0, 0.0),
+  pitch_range: tuple[float, float] = (0.0, 0.0),
+  yaw_range: tuple[float, float] = (0.0, 0.0),
+  distribution: Distribution | str = "uniform",
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> None:
+  """Randomize camera orientation by composing an RPY perturbation.
+
+  Ranges are in radians. The sampled perturbation is composed with the default
+  quaternion (not the current one), so repeated calls do not accumulate. The result is
+  always a valid unit quaternion.
+  """
+  _randomize_quat_field(
+    env,
+    env_ids,
+    "cam_quat",
+    entity_type="camera",
+    roll_range=roll_range,
+    pitch_range=pitch_range,
+    yaw_range=yaw_range,
+    distribution=distribution,
+    asset_cfg=asset_cfg,
+  )
+
+
+@requires_model_fields("cam_intrinsic")
+def cam_intrinsic(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize camera intrinsic parameters."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "cam_intrinsic",
+    entity_type="camera",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0, 1, 2, 3],
+  )
diff --git a/src/mjlab/envs/mdp/dr/geom.py b/src/mjlab/envs/mdp/dr/geom.py
new file mode 100644
index 0000000..ad22f97
--- /dev/null
+++ b/src/mjlab/envs/mdp/dr/geom.py
@@ -0,0 +1,325 @@
+"""Domain randomization functions for geom fields."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import mujoco
+import torch
+
+from mjlab.managers.event_manager import requires_model_fields
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+from ._core import (
+  _DEFAULT_ASSET_CFG,
+  Ranges,
+  _get_entity_indices,
+  _randomize_categorical_field,
+  _randomize_model_field,
+  _randomize_quat_field,
+)
+from ._types import Distribution, Operation
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+# MuJoCo geom type integer constants.
+_GEOM_SPHERE = mujoco.mjtGeom.mjGEOM_SPHERE.value
+_GEOM_CAPSULE = mujoco.mjtGeom.mjGEOM_CAPSULE.value
+_GEOM_ELLIPSOID = mujoco.mjtGeom.mjGEOM_ELLIPSOID.value
+_GEOM_CYLINDER = mujoco.mjtGeom.mjGEOM_CYLINDER.value
+_GEOM_BOX = mujoco.mjtGeom.mjGEOM_BOX.value
+
+
+def _recompute_geom_bounds(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor,
+  asset_cfg: SceneEntityCfg,
+) -> None:
+  """Recompute ``geom_rbound`` and ``geom_aabb`` from current ``geom_size``.
+
+  Only primitive types (sphere, capsule, ellipsoid, cylinder, box) are handled. Plane,
+  hfield, mesh, and SDF geoms are left unchanged.
+  """
+  asset = env.scene[asset_cfg.name]
+  entity_indices = _get_entity_indices(asset.indexing, asset_cfg, "geom", False)
+
+  env_grid, entity_grid = torch.meshgrid(env_ids, entity_indices, indexing="ij")
+  size = env.sim.model.geom_size[env_grid, entity_grid]  # (n_envs, n_geoms, 3)
+  s0, s1, s2 = size[..., 0], size[..., 1], size[..., 2]
+
+  # geom_type is (ngeom,) int, not per-world.
+  geom_type_all = torch.as_tensor(env.sim.model.geom_type, device=env.device)
+  gtype = geom_type_all[entity_indices]  # (G,) int
+
+  # Compute rbound per type via torch.where cascades.
+  rbound = torch.zeros_like(s0)
+
+  is_sphere = gtype[None, :] == _GEOM_SPHERE
+  is_capsule = gtype[None, :] == _GEOM_CAPSULE
+  is_ellipsoid = gtype[None, :] == _GEOM_ELLIPSOID
+  is_cylinder = gtype[None, :] == _GEOM_CYLINDER
+  is_box = gtype[None, :] == _GEOM_BOX
+
+  rbound = torch.where(is_sphere, s0, rbound)
+  rbound = torch.where(is_capsule, s0 + s1, rbound)
+  rbound = torch.where(is_ellipsoid, torch.maximum(s0, torch.maximum(s1, s2)), rbound)
+  rbound = torch.where(is_cylinder, torch.sqrt(s0 * s0 + s1 * s1), rbound)
+  rbound = torch.where(is_box, torch.sqrt(s0 * s0 + s1 * s1 + s2 * s2), rbound)
+
+  # Compute aabb half-sizes per type.
+  aabb_half_x = torch.zeros_like(s0)
+  aabb_half_y = torch.zeros_like(s0)
+  aabb_half_z = torch.zeros_like(s0)
+
+  # Sphere: (s0, s0, s0)
+  aabb_half_x = torch.where(is_sphere, s0, aabb_half_x)
+  aabb_half_y = torch.where(is_sphere, s0, aabb_half_y)
+  aabb_half_z = torch.where(is_sphere, s0, aabb_half_z)
+  # Capsule: (s0, s0, s0+s1)
+  aabb_half_x = torch.where(is_capsule, s0, aabb_half_x)
+  aabb_half_y = torch.where(is_capsule, s0, aabb_half_y)
+  aabb_half_z = torch.where(is_capsule, s0 + s1, aabb_half_z)
+  # Cylinder: (s0, s0, s1)
+  aabb_half_x = torch.where(is_cylinder, s0, aabb_half_x)
+  aabb_half_y = torch.where(is_cylinder, s0, aabb_half_y)
+  aabb_half_z = torch.where(is_cylinder, s1, aabb_half_z)
+  # Ellipsoid: (s0, s1, s2)
+  aabb_half_x = torch.where(is_ellipsoid, s0, aabb_half_x)
+  aabb_half_y = torch.where(is_ellipsoid, s1, aabb_half_y)
+  aabb_half_z = torch.where(is_ellipsoid, s2, aabb_half_z)
+  # Box: (s0, s1, s2)
+  aabb_half_x = torch.where(is_box, s0, aabb_half_x)
+  aabb_half_y = torch.where(is_box, s1, aabb_half_y)
+  aabb_half_z = torch.where(is_box, s2, aabb_half_z)
+
+  is_supported = is_sphere | is_capsule | is_ellipsoid | is_cylinder | is_box
+
+  if not is_supported.all():
+    unsupported = gtype[~is_supported[0]]
+    names = [mujoco.mjtGeom(t.item()).name for t in unsupported]
+    raise ValueError(
+      f"dr.geom_size only supports primitive geom types (sphere, capsule, "
+      f"ellipsoid, cylinder, box). Got unsupported types: {names}"
+    )
+
+  env.sim.model.geom_rbound[env_grid, entity_grid] = rbound
+
+  # aabb shape is (*, ngeom, 2, 3) — [0] is center, [1] is half-size.
+  # Center stays (0,0,0) for all primitives; only update half-size.
+  aabb_half = torch.stack([aabb_half_x, aabb_half_y, aabb_half_z], dim=-1)
+  env.sim.model.geom_aabb[env_grid, entity_grid, 1] = aabb_half
+
+
+# Per-field functions.
+
+
+@requires_model_fields("geom_friction")
+def geom_friction(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize geom friction.
+
+  Default axis is 0 (tangential friction only). Axes 1 (torsional) and 2 (rolling) only
+  affect contacts with ``condim >= 4``; pass ``axes=[0, 1, 2]`` explicitly if your
+  model uses high-dimensional contacts.
+  """
+  _randomize_model_field(
+    env,
+    env_ids,
+    "geom_friction",
+    entity_type="geom",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0],
+    valid_axes=[0, 1, 2],
+  )
+
+
+@requires_model_fields("geom_pos")
+def geom_pos(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize geom positions."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "geom_pos",
+    entity_type="geom",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0, 1, 2],
+  )
+
+
+@requires_model_fields("geom_quat")
+def geom_quat(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  roll_range: tuple[float, float] = (0.0, 0.0),
+  pitch_range: tuple[float, float] = (0.0, 0.0),
+  yaw_range: tuple[float, float] = (0.0, 0.0),
+  distribution: Distribution | str = "uniform",
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> None:
+  """Randomize geom orientation by composing an RPY perturbation.
+
+  Ranges are in radians. The sampled perturbation is composed with the default
+  quaternion (not the current one), so repeated calls do not accumulate. The result is
+  always a valid unit quaternion.
+  """
+  _randomize_quat_field(
+    env,
+    env_ids,
+    "geom_quat",
+    entity_type="geom",
+    roll_range=roll_range,
+    pitch_range=pitch_range,
+    yaw_range=yaw_range,
+    distribution=distribution,
+    asset_cfg=asset_cfg,
+  )
+
+
+@requires_model_fields("geom_rgba")
+def geom_rgba(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize geom RGBA colors.
+
+  Only affects rendering when the geom has no material assigned. If a material is
+  assigned, its color (or texture) takes precedence over ``geom_rgba``.
+  Use :func:`~mjlab.envs.mdp.dr.mat_rgba` instead, or clear the material assignment
+  first.
+
+  Args:
+    env: The environment instance.
+    env_ids: Environment indices to randomize. ``None`` means all.
+    ranges: Value range(s) for sampling.
+    asset_cfg: Entity and geom selection.
+    distribution: Sampling distribution.
+    operation: How to combine sampled values with the base.
+    axes: Which RGBA channels to randomize. Defaults to ``[0, 1, 2, 3]``.
+    shared_random: If ``True``, all selected geoms receive the same sampled value per
+      environment.
+  """
+  _randomize_model_field(
+    env,
+    env_ids,
+    "geom_rgba",
+    entity_type="geom",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0, 1, 2, 3],
+  )
+
+
+@requires_model_fields("geom_size", "geom_rbound", "geom_aabb")
+def geom_size(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "scale",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize geom size and recompute broadphase bounds.
+
+  After writing new values to ``geom_size``, this function automatically recomputes
+  ``geom_rbound`` (bounding sphere) and ``geom_aabb`` (local bounding box) so that the
+  broadphase remains consistent. Only primitive geom types (sphere, capsule, ellipsoid,
+  cylinder, box) are supported.
+  """
+  if env_ids is None:
+    env_ids = torch.arange(env.num_envs, device=env.device, dtype=torch.int)
+  else:
+    env_ids = env_ids.to(env.device, dtype=torch.int)
+
+  _randomize_model_field(
+    env,
+    env_ids,
+    "geom_size",
+    entity_type="geom",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0, 1, 2],
+  )
+  _recompute_geom_bounds(env, env_ids, asset_cfg)
+
+
+@requires_model_fields("geom_matid")
+def geom_matid(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  shared_random: bool = False,
+) -> None:
+  """Randomize which baked material each selected geom uses.
+
+  Each geom is assigned a material drawn uniformly from ``asset_cfg.material_names``.
+  Assigning a material to a geom that had none (``matid < 0``) switches its color
+  source from ``geom_rgba`` to the material's ``mat_rgba``/texture.
+
+  Args:
+    env: The environment instance.
+    env_ids: Environment indices to randomize. ``None`` means all.
+    asset_cfg: Entity, geom, and material selection.
+    shared_random: If ``True``, all selected geoms receive the same sampled value per
+      environment.
+  """
+  asset = env.scene[asset_cfg.name]
+  mat_ids = _get_entity_indices(asset.indexing, asset_cfg, "material", False)
+  if mat_ids.numel() == 0:
+    raise ValueError(
+      f"No materials selected for entity '{asset_cfg.name}'. Set "
+      "SceneEntityCfg.material_names to a non-empty selection."
+    )
+
+  _randomize_categorical_field(
+    env,
+    env_ids,
+    "geom_matid",
+    entity_type="geom",
+    pool=mat_ids,
+    asset_cfg=asset_cfg,
+    shared_random=shared_random,
+  )
diff --git a/src/mjlab/envs/mdp/dr/joint.py b/src/mjlab/envs/mdp/dr/joint.py
new file mode 100644
index 0000000..1bfe8a2
--- /dev/null
+++ b/src/mjlab/envs/mdp/dr/joint.py
@@ -0,0 +1,241 @@
+"""Domain randomization functions for joint and DOF fields."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.entity import Entity
+from mjlab.managers.event_manager import RecomputeLevel, requires_model_fields
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.utils.lab_api.math import sample_uniform
+
+from ._core import (
+  _DEFAULT_ASSET_CFG,
+  Ranges,
+  _randomize_model_field,
+)
+from ._types import Distribution, Operation
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+@requires_model_fields("dof_damping")
+def joint_damping(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize joint damping (dof_damping)."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "dof_damping",
+    entity_type="dof",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    use_address=True,
+  )
+
+
+# Raw alias.
+dof_damping = joint_damping
+
+
+@requires_model_fields("dof_armature", recompute=RecomputeLevel.set_const_0)
+def joint_armature(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize joint armature. Triggers ``set_const_0``."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "dof_armature",
+    entity_type="dof",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    use_address=True,
+  )
+
+
+# Raw alias.
+dof_armature = joint_armature
+
+
+@requires_model_fields("dof_frictionloss")
+def joint_friction(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize joint friction loss (dof_frictionloss)."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "dof_frictionloss",
+    entity_type="dof",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    use_address=True,
+  )
+
+
+# Raw alias.
+dof_frictionloss = joint_friction
+
+
+@requires_model_fields("jnt_stiffness")
+def joint_stiffness(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize joint stiffness (jnt_stiffness)."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "jnt_stiffness",
+    entity_type="joint",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+  )
+
+
+# Raw alias.
+jnt_stiffness = joint_stiffness
+
+
+@requires_model_fields("jnt_range")
+def joint_limits(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize joint limits (jnt_range)."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "jnt_range",
+    entity_type="joint",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+  )
+
+
+# Raw alias.
+jnt_range = joint_limits
+
+
+@requires_model_fields("qpos0", recompute=RecomputeLevel.set_const_0)
+def joint_default_pos(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "add",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize default joint positions (qpos0). Triggers ``set_const_0``."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "qpos0",
+    entity_type="joint",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    use_address=True,
+  )
+
+
+# Raw alias.
+qpos0 = joint_default_pos
+
+
+def encoder_bias(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  bias_range: tuple[float, float],
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> None:
+  """Randomize encoder bias to simulate joint encoder calibration errors."""
+  asset: Entity = env.scene[asset_cfg.name]
+
+  if env_ids is None:
+    env_ids = torch.arange(env.num_envs, device=env.device, dtype=torch.int)
+  else:
+    env_ids = env_ids.to(env.device, dtype=torch.int)
+
+  joint_ids = asset_cfg.joint_ids
+  if isinstance(joint_ids, slice):
+    num_joints = asset.num_joints
+    joint_ids_tensor = torch.arange(num_joints, device=env.device)
+  else:
+    joint_ids_tensor = torch.tensor(joint_ids, device=env.device)
+
+  num_joints = len(joint_ids_tensor)
+  bias_samples = sample_uniform(
+    torch.tensor(bias_range[0], device=env.device),
+    torch.tensor(bias_range[1], device=env.device),
+    (len(env_ids), num_joints),
+    env.device,
+  )
+
+  if isinstance(joint_ids, slice):
+    asset.data.encoder_bias[env_ids] = bias_samples
+  else:
+    asset.data.encoder_bias[env_ids[:, None], joint_ids_tensor] = bias_samples
diff --git a/src/mjlab/envs/mdp/dr/light.py b/src/mjlab/envs/mdp/dr/light.py
new file mode 100644
index 0000000..f25045b
--- /dev/null
+++ b/src/mjlab/envs/mdp/dr/light.py
@@ -0,0 +1,234 @@
+"""Domain randomization functions for light fields."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.managers.event_manager import requires_model_fields
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+from ._core import (
+  _DEFAULT_ASSET_CFG,
+  Ranges,
+  _randomize_model_field,
+)
+from ._types import Distribution, Operation
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+@requires_model_fields("light_pos")
+def light_pos(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize light positions."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "light_pos",
+    entity_type="light",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0, 1, 2],
+  )
+
+
+@requires_model_fields("light_dir")
+def light_dir(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize light direction vectors."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "light_dir",
+    entity_type="light",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0, 1, 2],
+  )
+
+
+@requires_model_fields("light_diffuse")
+def light_diffuse(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize light diffuse RGB color."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "light_diffuse",
+    entity_type="light",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0, 1, 2],
+  )
+
+
+@requires_model_fields("light_specular")
+def light_specular(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize light specular RGB color."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "light_specular",
+    entity_type="light",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0, 1, 2],
+  )
+
+
+@requires_model_fields("light_ambient")
+def light_ambient(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize light ambient RGB color."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "light_ambient",
+    entity_type="light",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0, 1, 2],
+  )
+
+
+@requires_model_fields("light_attenuation")
+def light_attenuation(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize light attenuation coefficients."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "light_attenuation",
+    entity_type="light",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0, 1, 2],
+  )
+
+
+@requires_model_fields("light_cutoff")
+def light_cutoff(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize spot light cutoff angles in degrees."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "light_cutoff",
+    entity_type="light",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+  )
+
+
+@requires_model_fields("light_exponent")
+def light_exponent(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize spot light angular falloff exponents."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "light_exponent",
+    entity_type="light",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+  )
diff --git a/src/mjlab/envs/mdp/dr/material.py b/src/mjlab/envs/mdp/dr/material.py
new file mode 100644
index 0000000..ce5c831
--- /dev/null
+++ b/src/mjlab/envs/mdp/dr/material.py
@@ -0,0 +1,230 @@
+"""Domain randomization functions for material fields."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import mujoco
+
+from mjlab.managers.event_manager import requires_model_fields
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+from ._core import (
+  _DEFAULT_ASSET_CFG,
+  Ranges,
+  _get_entity_indices,
+  _randomize_categorical_field,
+  _randomize_model_field,
+)
+from ._types import Distribution, Operation
+
+if TYPE_CHECKING:
+  import torch
+
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+@requires_model_fields("mat_rgba")
+def mat_rgba(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize material RGBA color.
+
+  In MuJoCo, a material's RGBA plays two roles depending on whether a texture is
+  assigned:
+
+  - **With texture**: ``mat_rgba`` is a multiplicative modulator. The rendered color
+    equals ``texture_color * mat_rgba`` per channel. ``(1, 1, 1, 1)`` leaves the
+    texture unchanged; values below 1 darken it.
+  - **Without texture**: ``mat_rgba`` directly sets the material's surface color,
+    similar to how :func:`~mjlab.envs.mdp.dr.geom_rgba` sets geom colors.
+
+  Note: If a geom has no material assigned (``matid < 0``), its color is controlled by
+  ``geom_rgba``, not ``mat_rgba``.
+
+  Args:
+    env: The environment instance.
+    env_ids: Environment indices to randomize. ``None`` means all.
+    ranges: Value range(s) for sampling.
+    asset_cfg: Entity and material selection. Use
+      ``SceneEntityCfg("entity", material_names=(...))`` to target specific materials.
+    distribution: Sampling distribution.
+    operation: How to combine sampled values with the base.
+    axes: Which RGBA channels to randomize. Defaults to ``[0, 1, 2, 3]``.
+    shared_random: If ``True``, all selected materials receive the same sampled
+      value per environment.
+  """
+  _randomize_model_field(
+    env,
+    env_ids,
+    "mat_rgba",
+    entity_type="material",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0, 1, 2, 3],
+  )
+
+
+@requires_model_fields("mat_emission")
+def mat_emission(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize material emission.
+
+  MuJoCo Warp's RGB renderer adds ``mat_emission * base_color`` per shaded
+  pixel, so higher values make the material appear self-illuminated.
+  """
+  _randomize_model_field(
+    env,
+    env_ids,
+    "mat_emission",
+    entity_type="material",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+  )
+
+
+@requires_model_fields("mat_specular")
+def mat_specular(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize material specular reflection strength.
+
+  MuJoCo stores specular in ``[0, 1]``. MuJoCo Warp uses it to scale the
+  specular component of RGB rendering.
+  """
+  _randomize_model_field(
+    env,
+    env_ids,
+    "mat_specular",
+    entity_type="material",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+  )
+
+
+@requires_model_fields("mat_shininess")
+def mat_shininess(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize material shininess.
+
+  MuJoCo stores shininess in ``[0, 1]``. MuJoCo Warp maps it to a Phong
+  exponent in ``[0, 128]`` during RGB rendering.
+  """
+  _randomize_model_field(
+    env,
+    env_ids,
+    "mat_shininess",
+    entity_type="material",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+  )
+
+
+@requires_model_fields("mat_texrepeat")
+def mat_texrepeat(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize material texture repeat in the S/T directions.
+
+  Only affects textured materials. Values should remain positive; zero or
+  negative texture repeats are not meaningful for rendering.
+  """
+  _randomize_model_field(
+    env,
+    env_ids,
+    "mat_texrepeat",
+    entity_type="material",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0, 1],
+  )
+
+
+@requires_model_fields("mat_texid")
+def mat_texid(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  role: int = mujoco.mjtTextureRole.mjTEXROLE_RGB.value,
+  shared_random: bool = False,
+) -> None:
+  """Randomize which texture each selected material uses.
+
+  A material stores one texture per ``mjtTextureRole`` slot; only the ``role``
+  slot is modified, drawn uniformly from ``asset_cfg.texture_names``.
+  """
+  asset = env.scene[asset_cfg.name]
+  tex_ids = _get_entity_indices(asset.indexing, asset_cfg, "texture", False)
+  if tex_ids.numel() == 0:
+    raise ValueError(
+      f"No textures selected for entity '{asset_cfg.name}'. Set "
+      "SceneEntityCfg.texture_names to a non-empty selection."
+    )
+
+  _randomize_categorical_field(
+    env,
+    env_ids,
+    "mat_texid",
+    entity_type="material",
+    pool=tex_ids,
+    asset_cfg=asset_cfg,
+    shared_random=shared_random,
+    axis=role,
+  )
diff --git a/src/mjlab/envs/mdp/dr/pair.py b/src/mjlab/envs/mdp/dr/pair.py
new file mode 100644
index 0000000..90000dc
--- /dev/null
+++ b/src/mjlab/envs/mdp/dr/pair.py
@@ -0,0 +1,91 @@
+"""Domain randomization functions for geom pair fields."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.managers.event_manager import requires_model_fields
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+from ._core import _DEFAULT_ASSET_CFG, Ranges, _randomize_model_field
+from ._types import Distribution, Operation
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+@requires_model_fields("pair_friction")
+def pair_friction(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+  isotropic: bool = False,
+) -> None:
+  """Randomize geom-pair friction overrides.
+
+  Pair friction has 5 components: ``[tangent1, tangent2, spin, roll1, roll2]``.
+  Default axis is 0 (tangent1 only). Axis 0 requires ``condim >= 3``
+  (the default); axes 1 and 2 require ``condim >= 4``; axes 3 and 4
+  require ``condim = 6``.
+
+  When ``isotropic=True``, tangent2 is set equal to tangent1 after sampling
+  (axis 1 is overwritten with axis 0). If axes 3 or 4 are targeted, roll2 is
+  also set equal to roll1 (axis 4 is overwritten with axis 3). This matches
+  MuJoCo's standard geom friction convention where both tangent directions and
+  both roll directions share one coefficient.
+
+  Args:
+    env: The environment instance.
+    env_ids: Environment indices to randomize. ``None`` means all.
+    ranges: Value range(s) for sampling.
+    asset_cfg: Entity and pair selection.
+    distribution: Sampling distribution.
+    operation: How to combine sampled values with the base.
+    axes: Which friction components to randomize. Defaults to ``[0]`` (tangent1).
+    shared_random: If ``True``, all selected pairs receive the same sampled value per
+      environment.
+    isotropic: If ``True``, mirror tangent2 = tangent1 after sampling (and
+      roll2 = roll1 if roll axes are targeted). Use this to maintain isotropic
+      friction, matching MuJoCo's geom friction convention.
+  """
+  _randomize_model_field(
+    env,
+    env_ids,
+    "pair_friction",
+    entity_type="pair",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0],
+    valid_axes=[0, 1, 2, 3, 4],
+  )
+
+  if isotropic:
+    _env_ids = (
+      torch.arange(env.num_envs, device=env.device, dtype=torch.int)
+      if env_ids is None
+      else env_ids.to(env.device, dtype=torch.int)
+    )
+    asset = env.scene[asset_cfg.name]
+    pair_indices = asset.indexing.pair_ids[asset_cfg.pair_ids]
+    env_grid, pair_grid = torch.meshgrid(_env_ids, pair_indices, indexing="ij")
+    pf = env.sim.model.pair_friction
+    pf[env_grid, pair_grid, 1] = pf[env_grid, pair_grid, 0]
+    if axes is not None:
+      effective_axes = axes
+    elif isinstance(ranges, dict) and ranges and isinstance(next(iter(ranges)), int):
+      effective_axes = list(ranges.keys())
+    else:
+      effective_axes = [0]
+    if 3 in effective_axes or 4 in effective_axes:
+      pf[env_grid, pair_grid, 4] = pf[env_grid, pair_grid, 3]
diff --git a/src/mjlab/envs/mdp/dr/site.py b/src/mjlab/envs/mdp/dr/site.py
new file mode 100644
index 0000000..54bcbe4
--- /dev/null
+++ b/src/mjlab/envs/mdp/dr/site.py
@@ -0,0 +1,77 @@
+"""Domain randomization functions for site fields."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.managers.event_manager import requires_model_fields
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+from ._core import (
+  _DEFAULT_ASSET_CFG,
+  Ranges,
+  _randomize_model_field,
+  _randomize_quat_field,
+)
+from ._types import Distribution, Operation
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+@requires_model_fields("site_pos")
+def site_pos(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize site positions."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "site_pos",
+    entity_type="site",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+    default_axes=[0, 1, 2],
+  )
+
+
+@requires_model_fields("site_quat")
+def site_quat(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  roll_range: tuple[float, float] = (0.0, 0.0),
+  pitch_range: tuple[float, float] = (0.0, 0.0),
+  yaw_range: tuple[float, float] = (0.0, 0.0),
+  distribution: Distribution | str = "uniform",
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> None:
+  """Randomize site orientation by composing an RPY perturbation.
+
+  Ranges are in radians. The sampled perturbation is composed with the default
+  quaternion (not the current one), so repeated calls do not accumulate. The result is
+  always a valid unit quaternion.
+  """
+  _randomize_quat_field(
+    env,
+    env_ids,
+    "site_quat",
+    entity_type="site",
+    roll_range=roll_range,
+    pitch_range=pitch_range,
+    yaw_range=yaw_range,
+    distribution=distribution,
+    asset_cfg=asset_cfg,
+  )
diff --git a/src/mjlab/envs/mdp/dr/tendon.py b/src/mjlab/envs/mdp/dr/tendon.py
new file mode 100644
index 0000000..971c6a5
--- /dev/null
+++ b/src/mjlab/envs/mdp/dr/tendon.py
@@ -0,0 +1,128 @@
+"""Domain randomization functions for tendon fields."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.managers.event_manager import RecomputeLevel, requires_model_fields
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+from ._core import (
+  _DEFAULT_ASSET_CFG,
+  Ranges,
+  _randomize_model_field,
+)
+from ._types import Distribution, Operation
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+@requires_model_fields("tendon_damping")
+def tendon_damping(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize tendon damping."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "tendon_damping",
+    entity_type="tendon",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+  )
+
+
+@requires_model_fields("tendon_stiffness")
+def tendon_stiffness(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize tendon stiffness."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "tendon_stiffness",
+    entity_type="tendon",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+  )
+
+
+@requires_model_fields("tendon_frictionloss")
+def tendon_friction(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize tendon friction loss (tendon_frictionloss)."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "tendon_frictionloss",
+    entity_type="tendon",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+  )
+
+
+# Raw alias.
+tendon_frictionloss = tendon_friction
+
+
+@requires_model_fields("tendon_armature", recompute=RecomputeLevel.set_const_0)
+def tendon_armature(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  ranges: Ranges,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+  distribution: Distribution | str = "uniform",
+  operation: Operation | str = "abs",
+  axes: list[int] | None = None,
+  shared_random: bool = False,
+) -> None:
+  """Randomize tendon armature. Triggers ``set_const_0``."""
+  _randomize_model_field(
+    env,
+    env_ids,
+    "tendon_armature",
+    entity_type="tendon",
+    ranges=ranges,
+    distribution=distribution,
+    operation=operation,
+    asset_cfg=asset_cfg,
+    axes=axes,
+    shared_random=shared_random,
+  )
diff --git a/src/mjlab/envs/mdp/events.py b/src/mjlab/envs/mdp/events.py
new file mode 100644
index 0000000..0872ec7
--- /dev/null
+++ b/src/mjlab/envs/mdp/events.py
@@ -0,0 +1,605 @@
+"""Useful methods for MDP events."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.entity import Entity
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.utils.lab_api.math import (
+  quat_apply,
+  quat_from_euler_xyz,
+  quat_mul,
+  sample_uniform,
+)
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+  from mjlab.viewer.debug_visualizer import DebugVisualizer
+
+_DEFAULT_ASSET_CFG = SceneEntityCfg("robot")
+_SE3_KEYS = ("x", "y", "z", "roll", "pitch", "yaw")
+
+
+def _sample_se3_range(
+  range_dict: dict[str, tuple[float, float]] | None,
+  shape: tuple[int, ...],
+  device: str,
+) -> torch.Tensor:
+  """Sample uniform ``[x, y, z, roll, pitch, yaw]`` offsets.
+
+  ``range_dict`` maps any subset of those keys to ``(min, max)`` ranges; missing
+  keys default to ``(0.0, 0.0)`` (no offset). ``None`` is treated as empty. The
+  returned tensor has the requested ``shape`` whose last dimension must be 6.
+  """
+  range_dict = range_dict or {}
+  range_list = [range_dict.get(key, (0.0, 0.0)) for key in _SE3_KEYS]
+  ranges = torch.tensor(range_list, device=device)
+  return sample_uniform(ranges[:, 0], ranges[:, 1], shape, device=device)
+
+
+def resolve_env_ids(
+  env: ManagerBasedRlEnv, env_ids: torch.Tensor | None
+) -> torch.Tensor:
+  """Return ``env_ids`` unchanged, or all environment indices if ``None``.
+
+  Event functions receive ``env_ids=None`` to mean "all environments" (a full
+  reset, or a global-time interval term). This normalizes that sentinel to a
+  concrete index tensor so the function body can assume a real ``torch.Tensor``.
+  """
+  if env_ids is None:
+    return torch.arange(env.num_envs, device=env.device, dtype=torch.int)
+  return env_ids
+
+
+def randomize_terrain(env: ManagerBasedRlEnv, env_ids: torch.Tensor | None) -> None:
+  """Randomize the sub-terrain for each environment on reset.
+
+  This picks a random terrain type (column) and difficulty level (row) for each
+  environment. Useful for play/evaluation mode to test on varied terrains.
+  """
+  env_ids = resolve_env_ids(env, env_ids)
+
+  terrain = env.scene.terrain
+  if terrain is not None:
+    terrain.randomize_env_origins(env_ids)
+
+
+def reset_scene_to_default(
+  env: ManagerBasedRlEnv, env_ids: torch.Tensor | None
+) -> None:
+  """Reset all entities in the scene to their default states.
+
+  For floating-base entities: Resets root state (position, orientation, velocities).
+  For fixed-base mocap entities: Resets mocap pose.
+  For all articulated entities: Resets joint positions and velocities.
+
+  Automatically applies env_origins offset to position all entities correctly.
+  """
+  env_ids = resolve_env_ids(env, env_ids)
+
+  for entity in env.scene.entities.values():
+    if not isinstance(entity, Entity):
+      continue
+
+    # Reset root/mocap pose.
+    if entity.is_fixed_base and entity.is_mocap:
+      # Fixed-base mocap entity - reset mocap pose with env_origins.
+      default_root_state = entity.data.default_root_state[env_ids].clone()
+      mocap_pose = torch.zeros((len(env_ids), 7), device=env.device)
+      mocap_pose[:, 0:3] = default_root_state[:, 0:3] + env.scene.env_origins[env_ids]
+      mocap_pose[:, 3:7] = default_root_state[:, 3:7]
+      entity.write_mocap_pose_to_sim(mocap_pose, env_ids=env_ids)
+    elif not entity.is_fixed_base:
+      # Floating-base entity - reset root state with env_origins.
+      default_root_state = entity.data.default_root_state[env_ids].clone()
+      default_root_state[:, 0:3] += env.scene.env_origins[env_ids]
+      entity.write_root_state_to_sim(default_root_state, env_ids=env_ids)
+
+    # Reset joint state for articulated entities.
+    if entity.is_articulated:
+      default_joint_pos = entity.data.default_joint_pos[env_ids].clone()
+      default_joint_vel = entity.data.default_joint_vel[env_ids].clone()
+      entity.write_joint_state_to_sim(
+        default_joint_pos, default_joint_vel, env_ids=env_ids
+      )
+
+
+def reset_root_state_uniform(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  pose_range: dict[str, tuple[float, float]],
+  velocity_range: dict[str, tuple[float, float]] | None = None,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> None:
+  """Reset root state for floating-base or mocap fixed-base entities.
+
+  For floating-base entities: Resets pose and velocity via write_root_state_to_sim().
+  For fixed-base mocap entities: Resets pose only via write_mocap_pose_to_sim().
+
+  .. note::
+    This function applies the env_origins offset to position entities in a grid.
+    For fixed-base robots, this is the ONLY way to position them per-environment.
+    Without calling this function in a reset event, fixed-base robots will stack
+    at (0,0,0).
+
+  See FAQ: "Why are my fixed-base robots all stacked at the origin?"
+
+  Args:
+    env: The environment.
+    env_ids: Environment IDs to reset. If None, resets all environments.
+    pose_range: Dictionary with keys {"x", "y", "z", "roll", "pitch", "yaw"}.
+    velocity_range: Velocity range (only used for floating-base entities).
+    asset_cfg: Asset configuration.
+  """
+  env_ids = resolve_env_ids(env, env_ids)
+
+  asset: Entity = env.scene[asset_cfg.name]
+
+  # Pose.
+  pose_samples = _sample_se3_range(pose_range, (len(env_ids), 6), env.device)
+
+  # Fixed-based entities with mocap=True.
+  if asset.is_fixed_base:
+    if not asset.is_mocap:
+      raise ValueError(
+        f"Cannot reset root state for fixed-base non-mocap entity '{asset_cfg.name}'."
+      )
+
+    default_root_state = asset.data.default_root_state
+    assert default_root_state is not None
+    root_states = default_root_state[env_ids].clone()
+
+    positions = (
+      root_states[:, 0:3] + pose_samples[:, 0:3] + env.scene.env_origins[env_ids]
+    )
+    orientations_delta = quat_from_euler_xyz(
+      pose_samples[:, 3], pose_samples[:, 4], pose_samples[:, 5]
+    )
+    orientations = quat_mul(root_states[:, 3:7], orientations_delta)
+
+    asset.write_mocap_pose_to_sim(
+      torch.cat([positions, orientations], dim=-1), env_ids=env_ids
+    )
+    return
+
+  # Floating-base entities.
+  default_root_state = asset.data.default_root_state
+  assert default_root_state is not None
+  root_states = default_root_state[env_ids].clone()
+
+  positions = (
+    root_states[:, 0:3] + pose_samples[:, 0:3] + env.scene.env_origins[env_ids]
+  )
+  orientations_delta = quat_from_euler_xyz(
+    pose_samples[:, 3], pose_samples[:, 4], pose_samples[:, 5]
+  )
+  orientations = quat_mul(root_states[:, 3:7], orientations_delta)
+
+  # Velocities.
+  vel_samples = _sample_se3_range(velocity_range, (len(env_ids), 6), env.device)
+  velocities = root_states[:, 7:13] + vel_samples
+
+  asset.write_root_link_pose_to_sim(
+    torch.cat([positions, orientations], dim=-1), env_ids=env_ids
+  )
+
+  asset.write_root_link_velocity_to_sim(velocities, env_ids=env_ids)
+
+
+def reset_root_state_from_flat_patches(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  patch_name: str = "spawn",
+  pose_range: dict[str, tuple[float, float]] | None = None,
+  velocity_range: dict[str, tuple[float, float]] | None = None,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> None:
+  """Reset root state by placing the asset on a randomly chosen flat patch.
+
+  Selects a random flat patch from the terrain for each environment and positions
+  the asset there. Falls back to ``reset_root_state_uniform`` if the terrain has
+  no flat patches.
+
+  Args:
+    env: The environment.
+    env_ids: Environment IDs to reset. If None, resets all environments.
+    patch_name: Key into ``terrain.flat_patches`` to use.
+    pose_range: Optional random offset applied on top of the patch position.
+      Keys: ``{"x", "y", "z", "roll", "pitch", "yaw"}``.
+    velocity_range: Optional velocity range (floating-base only).
+    asset_cfg: Asset configuration.
+  """
+  env_ids = resolve_env_ids(env, env_ids)
+
+  terrain = env.scene.terrain
+  if terrain is None or patch_name not in terrain.flat_patches:
+    reset_root_state_uniform(
+      env,
+      env_ids,
+      pose_range=pose_range or {},
+      velocity_range=velocity_range,
+      asset_cfg=asset_cfg,
+    )
+    return
+
+  patches = terrain.flat_patches[patch_name]  # (num_rows, num_cols, num_patches, 3)
+  num_patches = patches.shape[2]
+
+  # Look up terrain level (row) and type (col) for each env.
+  levels = terrain.terrain_levels[env_ids]
+  types = terrain.terrain_types[env_ids]
+
+  # Randomly select a patch index for each env.
+  patch_ids = torch.randint(0, num_patches, (len(env_ids),), device=env.device)
+  positions = patches[levels, types, patch_ids]
+
+  asset: Entity = env.scene[asset_cfg.name]
+  default_root_state = asset.data.default_root_state
+  assert default_root_state is not None
+  root_states = default_root_state[env_ids].clone()
+
+  # Apply optional pose range offset.
+  pose_samples = _sample_se3_range(pose_range, (len(env_ids), 6), env.device)
+
+  # Position: flat patch position + optional offset. Use patch z instead of default.
+  final_positions = positions.clone()
+  final_positions[:, 0] += pose_samples[:, 0]
+  final_positions[:, 1] += pose_samples[:, 1]
+  final_positions[:, 2] += root_states[:, 2] + pose_samples[:, 2]
+
+  orientations_delta = quat_from_euler_xyz(
+    pose_samples[:, 3], pose_samples[:, 4], pose_samples[:, 5]
+  )
+  orientations = quat_mul(root_states[:, 3:7], orientations_delta)
+
+  if asset.is_fixed_base:
+    if not asset.is_mocap:
+      raise ValueError(
+        f"Cannot reset root state for fixed-base non-mocap entity '{asset_cfg.name}'."
+      )
+    asset.write_mocap_pose_to_sim(
+      torch.cat([final_positions, orientations], dim=-1), env_ids=env_ids
+    )
+    return
+
+  # Velocities.
+  vel_samples = _sample_se3_range(velocity_range, (len(env_ids), 6), env.device)
+  velocities = root_states[:, 7:13] + vel_samples
+
+  asset.write_root_link_pose_to_sim(
+    torch.cat([final_positions, orientations], dim=-1), env_ids=env_ids
+  )
+  asset.write_root_link_velocity_to_sim(velocities, env_ids=env_ids)
+
+
+def reset_joints_by_offset(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  position_range: tuple[float, float],
+  velocity_range: tuple[float, float],
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> None:
+  env_ids = resolve_env_ids(env, env_ids)
+
+  asset: Entity = env.scene[asset_cfg.name]
+  default_joint_pos = asset.data.default_joint_pos
+  assert default_joint_pos is not None
+  default_joint_vel = asset.data.default_joint_vel
+  assert default_joint_vel is not None
+  soft_joint_pos_limits = asset.data.soft_joint_pos_limits
+  assert soft_joint_pos_limits is not None
+
+  joint_pos = default_joint_pos[env_ids][:, asset_cfg.joint_ids].clone()
+  joint_pos += sample_uniform(*position_range, joint_pos.shape, env.device)
+  joint_pos_limits = soft_joint_pos_limits[env_ids][:, asset_cfg.joint_ids]
+  joint_pos = joint_pos.clamp_(joint_pos_limits[..., 0], joint_pos_limits[..., 1])
+
+  joint_vel = default_joint_vel[env_ids][:, asset_cfg.joint_ids].clone()
+  joint_vel += sample_uniform(*velocity_range, joint_vel.shape, env.device)
+
+  joint_ids = asset_cfg.joint_ids
+  if isinstance(joint_ids, list):
+    joint_ids = torch.tensor(joint_ids, device=env.device)
+
+  asset.write_joint_state_to_sim(
+    joint_pos.view(len(env_ids), -1),
+    joint_vel.view(len(env_ids), -1),
+    env_ids=env_ids,
+    joint_ids=joint_ids,
+  )
+
+
+def push_by_setting_velocity(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  velocity_range: dict[str, tuple[float, float]],
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> None:
+  """Push an entity by overwriting its root velocity with a sampled offset.
+
+  This is an *instantaneous, mass-independent* kick: it adds a uniformly sampled
+  delta directly to the root velocity, ignoring inertia and contact dynamics. It
+  is the cheapest disturbance and the standard locomotion "push the robot" term.
+  Use with ``mode="interval"``.
+
+  For force-based disturbances that respect the entity's dynamics, see
+  :func:`apply_external_force_torque` (a constant wrench you manage yourself) or
+  :class:`apply_body_impulse` (transient, self-managing impulses).
+  """
+  env_ids = resolve_env_ids(env, env_ids)
+  asset: Entity = env.scene[asset_cfg.name]
+  vel_w = asset.data.root_link_vel_w[env_ids]
+  vel_w += _sample_se3_range(velocity_range, vel_w.shape, env.device)
+  asset.write_root_link_velocity_to_sim(vel_w, env_ids=env_ids)
+
+
+def apply_external_force_torque(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor | None,
+  force_range: tuple[float, float],
+  torque_range: tuple[float, float],
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> None:
+  """Apply a single *constant* external wrench to bodies.
+
+  Samples a force and torque once and writes them to ``xfrc_applied``. The wrench
+  is **stateless and never expires**: MuJoCo holds it constant on every physics
+  step until something overwrites or zeroes it. There is no duration, cooldown,
+  or auto-clear.
+
+  **When to use this vs.** :class:`apply_body_impulse`:
+
+  - Use ``apply_external_force_torque`` for a *steady, episode-long* disturbance
+    such as a fixed payload, a constant wind, or a sustained load. The intended
+    pattern is ``mode="reset"``: re-randomize the wrench each episode so it holds
+    for that episode's duration. Because it never turns itself off, **you are
+    responsible for clearing or overwriting it** (e.g. via the next reset). It is
+    *not* suited to transient bumps on its own.
+
+  - Use :class:`apply_body_impulse` for *transient, repeated, randomized*
+    disturbances during an episode (bumps, gusts, collisions). It runs a full
+    cooldown -> trigger -> sustain -> expire lifecycle per environment, zeroing
+    the wrench automatically when each impulse ends, and ticks on ``mode="step"``.
+
+  For an instantaneous, mass-independent kick instead of a force, see
+  :func:`push_by_setting_velocity`.
+  """
+  env_ids = resolve_env_ids(env, env_ids)
+  asset: Entity = env.scene[asset_cfg.name]
+  num_bodies = (
+    len(asset_cfg.body_ids)
+    if isinstance(asset_cfg.body_ids, list)
+    else asset.num_bodies
+  )
+  size = (len(env_ids), num_bodies, 3)
+  forces = sample_uniform(*force_range, size, env.device)
+  torques = sample_uniform(*torque_range, size, env.device)
+  asset.write_external_wrench_to_sim(
+    forces, torques, env_ids=env_ids, body_ids=asset_cfg.body_ids
+  )
+
+
+class apply_body_impulse:
+  """Apply random impulses to bodies for a sampled duration.
+
+  Simulates transient external disturbances such as bumps, wind gusts, or
+  collisions with unseen objects. A constant force/torque wrench is applied
+  to one or more bodies for a randomly sampled duration, followed by a
+  cooldown period of silence before the next impulse.
+
+  **Lifecycle of a single impulse:**
+
+  1. **Cooldown.** The event is idle for a random duration sampled from ``cooldown_s``.
+    No force is applied.
+  2. **Trigger.** A force vector is sampled uniformly per component from ``force_range``
+    and written to ``xfrc_applied`` on the selected bodies.
+  3. **Sustain.** The force is held constant for a random duration sampled from
+    ``duration_s``.
+  4. **Expire.** The force is zeroed and the cooldown restarts at step 1.
+
+  Each environment runs its own independent timer so impulses are decorrelated across
+  the batch.
+
+  **Application point.** By default, forces act at each body's center of mass.
+  ``body_point_offset`` shifts the application point in the body's local frame, for
+  example ``(0, 0, 0.1)`` for 10 cm above the CoM. The offset produces additional
+  torque via the cross product ``offset x force``, causing the body to tip rather than
+  just translate. This is analogous to choosing where on the body an external push is
+  applied.
+
+  Use with ``mode="step"``.
+
+  For a *constant* episode-long wrench instead of transient impulses, see
+  :func:`apply_external_force_torque`. For an instantaneous, mass-independent
+  velocity kick, see :func:`push_by_setting_velocity`.
+  """
+
+  @dataclass
+  class VizCfg:
+    """Arrow visualization settings for active impulse forces."""
+
+    rgba: tuple[float, float, float, float] = (0.9, 0.2, 0.8, 0.9)
+    """Arrow color (RGBA)."""
+    scale: float = 0.005
+    """Arrow length in meters per Newton of force."""
+    width: float = 0.015
+    """Arrow shaft width in meters."""
+    min_force: float = 1.0
+    """Minimum force magnitude (N) below which arrows are hidden."""
+
+  def __init__(self, cfg, env: ManagerBasedRlEnv):
+    self._asset: Entity = env.scene[cfg.params["asset_cfg"].name]
+    self._body_ids = cfg.params["asset_cfg"].body_ids
+    self._num_envs = env.num_envs
+    self._device = env.device
+    self._step_dt = env.step_dt
+    self._viz_cfg: apply_body_impulse.VizCfg = cfg.params.get(
+      "viz_cfg", apply_body_impulse.VizCfg()
+    )
+    offset = cfg.params.get("body_point_offset", None)
+    self._body_point_offset: torch.Tensor | None = (
+      torch.tensor(offset, device=self._device, dtype=torch.float32)
+      if offset is not None
+      else None
+    )
+
+    self._num_bodies = (
+      len(self._body_ids)
+      if isinstance(self._body_ids, list)
+      else self._asset.num_bodies
+    )
+
+    self._cooldown_s: tuple[float, float] = cfg.params["cooldown_s"]
+    self._time_remaining = torch.zeros(self._num_envs, device=self._device)
+    self._active = torch.zeros(self._num_envs, device=self._device, dtype=torch.bool)
+    # Pre-sample the initial cooldown so the first impulse is preceded by a cooldown
+    # rather than firing immediately at t=0.
+    self._interval_time_left = self._sample_cooldown(self._num_envs)
+
+  def _sample_cooldown(self, n: int) -> torch.Tensor:
+    low, high = self._cooldown_s
+    return sample_uniform(low, high, n, self._device)
+
+  def __call__(
+    self,
+    env: ManagerBasedRlEnv,
+    env_ids: torch.Tensor | None,
+    force_range: tuple[float, float],
+    torque_range: tuple[float, float],
+    duration_s: tuple[float, float],
+    cooldown_s: tuple[float, float],
+    asset_cfg: SceneEntityCfg,
+    body_point_offset: tuple[float, float, float] | None = None,
+  ) -> None:
+    """Tick impulse state: expire old impulses, trigger new ones.
+
+    Args:
+      env: The environment instance.
+      env_ids: Unused (step events always operate on all envs).
+      force_range: ``(min, max)`` uniform range for each force component (N).
+      torque_range: ``(min, max)`` uniform range for each torque component (Nm).
+      duration_s: ``(min, max)`` uniform range for impulse duration in seconds.
+      cooldown_s: ``(min, max)`` uniform range for the cooldown between consecutive
+        impulses in seconds. Captured at init so the first impulse can be
+        preceded by a sampled cooldown; the kwarg passed here is unused.
+      asset_cfg: Entity and body selection. ``body_ids`` on the config selects which
+        bodies receive forces.
+      body_point_offset: Optional ``(x, y, z)`` offset in the body frame where the
+        force is applied. Generates additional torque via ``cross(offset, force)``.
+    """
+    del env, env_ids, asset_cfg, cooldown_s  # Unused at call time.
+    dt = self._step_dt
+
+    # Decrement timers for active envs.
+    self._time_remaining[self._active] -= dt
+
+    # Clear expired impulses and resample their interval timers.
+    expired = self._active & (self._time_remaining <= 0)
+    if expired.any():
+      expired_ids = expired.nonzero(as_tuple=False).squeeze(-1)
+      zeros = torch.zeros((len(expired_ids), self._num_bodies, 3), device=self._device)
+      self._asset.write_external_wrench_to_sim(
+        zeros, zeros, env_ids=expired_ids, body_ids=self._body_ids
+      )
+      self._active[expired_ids] = False
+      self._time_remaining[expired_ids] = 0.0
+      self._interval_time_left[expired_ids] = self._sample_cooldown(len(expired_ids))
+
+    # Decrement interval timers.
+    self._interval_time_left -= dt
+
+    # Trigger new impulses for eligible envs.
+    eligible = (~self._active) & (self._interval_time_left <= 0)
+    if not eligible.any():
+      return
+
+    trigger_ids = eligible.nonzero(as_tuple=False).squeeze(-1)
+    n = len(trigger_ids)
+
+    # Sample forces and torques.
+    size = (n, self._num_bodies, 3)
+    forces = sample_uniform(*force_range, size, self._device)
+    torques = sample_uniform(*torque_range, size, self._device)
+
+    # Adjust torque for off-CoM application point.
+    if body_point_offset is not None:
+      offset_local = torch.tensor(
+        body_point_offset, device=self._device, dtype=torch.float32
+      )
+      body_quat = self._asset.data.body_com_quat_w[trigger_ids][:, self._body_ids]
+      # Rotate offset into world frame: (n, num_bodies, 3).
+      offset_w = quat_apply(
+        body_quat.reshape(-1, 4), offset_local.expand(n * self._num_bodies, 3)
+      ).reshape(n, self._num_bodies, 3)
+      torques = torques + torch.cross(offset_w, forces, dim=-1)
+
+    self._asset.write_external_wrench_to_sim(
+      forces, torques, env_ids=trigger_ids, body_ids=self._body_ids
+    )
+
+    # Sample duration and set timers.
+    dur_low, dur_high = duration_s
+    self._time_remaining[trigger_ids] = (
+      torch.rand(n, device=self._device) * (dur_high - dur_low) + dur_low
+    )
+    self._active[trigger_ids] = True
+
+    # Resample interval timers.
+    self._interval_time_left[trigger_ids] = self._sample_cooldown(n)
+
+  def debug_vis(self, visualizer: DebugVisualizer) -> None:
+    """Draw arrows for active impulse forces."""
+    if not self._active.any():
+      return
+    viz = self._viz_cfg
+    min_sq = viz.min_force * viz.min_force
+    wrench = self._asset.data.body_external_wrench  # (nworld, nbody, 6)
+    com_pos = self._asset.data.body_com_pos_w  # (nworld, nbody, 3)
+    offset = self._body_point_offset
+    com_quat = self._asset.data.body_com_quat_w if offset is not None else None
+    for env_idx in visualizer.get_env_indices(self._num_envs):
+      if not self._active[env_idx]:
+        continue
+      for i in range(wrench.shape[1]):
+        force = wrench[env_idx, i, :3]
+        if (force * force).sum().item() < min_sq:
+          continue
+        force_np = force.cpu().numpy()
+        start_np = com_pos[env_idx, i].cpu().numpy()
+        if offset is not None and com_quat is not None:
+          offset_w = quat_apply(com_quat[env_idx, i], offset)
+          start_np = start_np + offset_w.cpu().numpy()
+        end_np = start_np + force_np * viz.scale
+        visualizer.add_arrow(
+          start=start_np,
+          end=end_np,
+          color=viz.rgba,
+          width=viz.width,
+        )
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    if env_ids is None:
+      env_ids = slice(None)
+
+    if self._active[env_ids].any():
+      if isinstance(env_ids, slice):
+        active_ids = self._active.nonzero(as_tuple=False).squeeze(-1)
+      else:
+        active_ids = env_ids[self._active[env_ids]]
+      if len(active_ids) > 0:
+        zeros = torch.zeros(
+          (len(active_ids), self._num_bodies, 3),
+          device=self._device,
+        )
+        self._asset.write_external_wrench_to_sim(
+          zeros, zeros, env_ids=active_ids, body_ids=self._body_ids
+        )
+
+    n = self._num_envs if isinstance(env_ids, slice) else len(env_ids)
+    self._time_remaining[env_ids] = 0.0
+    self._interval_time_left[env_ids] = self._sample_cooldown(n)
+    self._active[env_ids] = False
diff --git a/src/mjlab/envs/mdp/metrics.py b/src/mjlab/envs/mdp/metrics.py
new file mode 100644
index 0000000..09f956f
--- /dev/null
+++ b/src/mjlab/envs/mdp/metrics.py
@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+def mean_action_acc(env: ManagerBasedRlEnv) -> torch.Tensor:
+  """Mean absolute action acceleration.
+
+  Lower values indicate smoother actions.
+
+  Returns:
+    Per-environment scalar. Shape: ``(B,)``.
+  """
+  # Discrete second derivative: a_t - 2 * a_{t-1} + a_{t-2}.  (B, N)
+  action_acc = (
+    env.action_manager.action
+    - 2 * env.action_manager.prev_action
+    + env.action_manager.prev_prev_action
+  )
+  return torch.mean(torch.abs(action_acc), dim=-1)  # (B,)
diff --git a/src/mjlab/envs/mdp/observations.py b/src/mjlab/envs/mdp/observations.py
new file mode 100644
index 0000000..92cbf40
--- /dev/null
+++ b/src/mjlab/envs/mdp/observations.py
@@ -0,0 +1,163 @@
+"""Useful methods for MDP observations."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.entity import Entity
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.sensor import BuiltinSensor, RayCastSensor
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+_DEFAULT_ASSET_CFG = SceneEntityCfg("robot")
+
+
+##
+# Root state.
+##
+
+
+def base_lin_vel(
+  env: ManagerBasedRlEnv, asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG
+) -> torch.Tensor:
+  asset: Entity = env.scene[asset_cfg.name]
+  return asset.data.root_link_lin_vel_b
+
+
+def base_ang_vel(
+  env: ManagerBasedRlEnv, asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG
+) -> torch.Tensor:
+  asset: Entity = env.scene[asset_cfg.name]
+  return asset.data.root_link_ang_vel_b
+
+
+def projected_gravity(
+  env: ManagerBasedRlEnv,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  asset: Entity = env.scene[asset_cfg.name]
+  return asset.data.projected_gravity_b
+
+
+##
+# Joint state.
+##
+
+
+def joint_pos_rel(
+  env: ManagerBasedRlEnv,
+  biased: bool = False,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  asset: Entity = env.scene[asset_cfg.name]
+  default_joint_pos = asset.data.default_joint_pos
+  assert default_joint_pos is not None
+  jnt_ids = asset_cfg.joint_ids
+  joint_pos = asset.data.joint_pos_biased if biased else asset.data.joint_pos
+  return joint_pos[:, jnt_ids] - default_joint_pos[:, jnt_ids]
+
+
+def joint_vel_rel(
+  env: ManagerBasedRlEnv,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  asset: Entity = env.scene[asset_cfg.name]
+  default_joint_vel = asset.data.default_joint_vel
+  assert default_joint_vel is not None
+  jnt_ids = asset_cfg.joint_ids
+  return asset.data.joint_vel[:, jnt_ids] - default_joint_vel[:, jnt_ids]
+
+
+##
+# Actions.
+##
+
+
+def last_action(env: ManagerBasedRlEnv, action_name: str | None = None) -> torch.Tensor:
+  if action_name is None:
+    return env.action_manager.action
+  return env.action_manager.get_term(action_name).raw_action
+
+
+##
+# Commands.
+##
+
+
+def generated_commands(env: ManagerBasedRlEnv, command_name: str) -> torch.Tensor:
+  command = env.command_manager.get_command(command_name)
+  assert command is not None
+  return command
+
+
+##
+# Sensors.
+##
+
+
+def builtin_sensor(env: ManagerBasedRlEnv, sensor_name: str) -> torch.Tensor:
+  """Get observation from a built-in sensor by name."""
+  sensor = env.scene[sensor_name]
+  assert isinstance(sensor, BuiltinSensor)
+  return sensor.data
+
+
+def projected_gravity_from_sensor(
+  env: ManagerBasedRlEnv, sensor_name: str
+) -> torch.Tensor:
+  """Projected gravity from a ``framezaxis`` up-vector sensor.
+
+  The sensor is expected to output the world Z-axis expressed in the sensor's frame
+  (e.g. ``framezaxis`` with ``objtype=body objname=world`` and ``reftype=site``). That
+  is the body-frame "up" vector, so it is negated to point along gravity.
+
+  Unlike :func:`projected_gravity`, which uses the root body orientation, this reads
+  the sensor's site frame and therefore reflects IMU site pose randomization.
+  """
+  sensor = env.scene[sensor_name]
+  assert isinstance(sensor, BuiltinSensor)
+  return -sensor.data
+
+
+def height_scan(
+  env: ManagerBasedRlEnv,
+  sensor_name: str,
+  offset: float = 0.0,
+  miss_value: float | None = None,
+) -> torch.Tensor:
+  """Height scan from a raycast sensor.
+
+  Returns the height of the sensor frame above each hit point.
+  Supports multi-frame sensors: each ray uses its own frame's Z.
+
+  Args:
+    env: The environment.
+    sensor_name: Name of a RayCastSensor in the scene.
+    offset: Constant offset subtracted from heights.
+    miss_value: Value to use for rays that miss (distance < 0).
+      Defaults to the sensor's ``max_distance``.
+
+  Returns:
+    Tensor of shape [B, N] where N = num_frames * num_rays_per_frame.
+    Rays are ordered frame-major (all rays for frame 0, then frame 1, etc.).
+  """
+  sensor: RayCastSensor = env.scene[sensor_name]
+  if miss_value is None:
+    miss_value = sensor.cfg.max_distance
+
+  data = sensor.data
+  F, N = sensor.num_frames, sensor.num_rays_per_frame
+  B = data.distances.shape[0]
+
+  # Each ray's height = its frame's Z - hit Z. For single-frame sensors (F=1) this
+  # reduces to the original pos_w[:, 2] - hit_z broadcast.
+  frame_z = data.frame_pos_w[:, :, 2:3]  # [B, F, 1]
+  hit_z = data.hit_pos_w[..., 2].view(B, F, N)  # [B, F, N]
+  heights = (frame_z - hit_z - offset).view(B, F * N)
+
+  miss_mask = data.distances < 0
+  return torch.where(miss_mask, torch.full_like(heights, miss_value), heights)
diff --git a/src/mjlab/envs/mdp/rewards.py b/src/mjlab/envs/mdp/rewards.py
new file mode 100644
index 0000000..8712d83
--- /dev/null
+++ b/src/mjlab/envs/mdp/rewards.py
@@ -0,0 +1,159 @@
+"""Useful methods for MDP rewards."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.entity import Entity
+from mjlab.managers.reward_manager import RewardTermCfg
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.utils.lab_api.string import (
+  resolve_matching_names_values,
+)
+
+if TYPE_CHECKING:
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+
+_DEFAULT_ASSET_CFG = SceneEntityCfg("robot")
+
+
+def is_alive(env: ManagerBasedRlEnv) -> torch.Tensor:
+  """Reward for being alive."""
+  return (~env.termination_manager.terminated).float()
+
+
+def is_terminated(env: ManagerBasedRlEnv) -> torch.Tensor:
+  """Penalize terminated episodes that don't correspond to episodic timeouts."""
+  return env.termination_manager.terminated.float()
+
+
+def joint_torques_l2(
+  env: ManagerBasedRlEnv, asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG
+) -> torch.Tensor:
+  """Penalize joint torques applied on the articulation using L2 squared kernel."""
+  asset: Entity = env.scene[asset_cfg.name]
+  return torch.sum(
+    torch.square(asset.data.actuator_force[:, asset_cfg.actuator_ids]), dim=1
+  )
+
+
+def joint_vel_l2(
+  env: ManagerBasedRlEnv, asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG
+) -> torch.Tensor:
+  """Penalize joint velocities on the articulation using L2 squared kernel."""
+  asset: Entity = env.scene[asset_cfg.name]
+  return torch.sum(torch.square(asset.data.joint_vel[:, asset_cfg.joint_ids]), dim=1)
+
+
+def joint_acc_l2(
+  env: ManagerBasedRlEnv, asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG
+) -> torch.Tensor:
+  """Penalize joint accelerations on the articulation using L2 squared kernel."""
+  asset: Entity = env.scene[asset_cfg.name]
+  return torch.sum(torch.square(asset.data.joint_acc[:, asset_cfg.joint_ids]), dim=1)
+
+
+def action_rate_l2(env: ManagerBasedRlEnv) -> torch.Tensor:
+  """Penalize the rate of change of the actions using L2 squared kernel.
+
+  Operates on raw policy output (before per-term scale/offset).
+  """
+  return torch.sum(
+    torch.square(env.action_manager.action - env.action_manager.prev_action), dim=1
+  )
+
+
+def action_acc_l2(env: ManagerBasedRlEnv) -> torch.Tensor:
+  """Penalize the acceleration of the actions using L2 squared kernel.
+
+  Operates on raw policy output (before per-term scale/offset).
+  """
+  action_acc = (
+    env.action_manager.action
+    - 2 * env.action_manager.prev_action
+    + env.action_manager.prev_prev_action
+  )
+  return torch.sum(torch.square(action_acc), dim=1)
+
+
+def joint_pos_limits(
+  env: ManagerBasedRlEnv, asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG
+) -> torch.Tensor:
+  """Penalize joint positions if they cross the soft limits."""
+  asset: Entity = env.scene[asset_cfg.name]
+  soft_joint_pos_limits = asset.data.soft_joint_pos_limits
+  assert soft_joint_pos_limits is not None
+  out_of_limits = -(
+    asset.data.joint_pos[:, asset_cfg.joint_ids]
+    - soft_joint_pos_limits[:, asset_cfg.joint_ids, 0]
+  ).clip(max=0.0)
+  out_of_limits += (
+    asset.data.joint_pos[:, asset_cfg.joint_ids]
+    - soft_joint_pos_limits[:, asset_cfg.joint_ids, 1]
+  ).clip(min=0.0)
+  return torch.sum(out_of_limits, dim=1)
+
+
+class posture:
+  """Penalize the deviation of the joint positions from the default positions.
+
+  Note: This is implemented as a class so that we can resolve the standard deviation
+  dictionary into a tensor and thereafter use it in the __call__ method.
+  """
+
+  def __init__(self, cfg: RewardTermCfg, env: ManagerBasedRlEnv):
+    asset: Entity = env.scene[cfg.params["asset_cfg"].name]
+    default_joint_pos = asset.data.default_joint_pos
+    assert default_joint_pos is not None
+    self.default_joint_pos = default_joint_pos
+
+    _, joint_names = asset.find_joints(
+      cfg.params["asset_cfg"].joint_names,
+    )
+
+    _, _, std = resolve_matching_names_values(
+      data=cfg.params["std"],
+      list_of_strings=joint_names,
+    )
+    self.std = torch.tensor(std, device=env.device, dtype=torch.float32)
+
+  def __call__(
+    self, env: ManagerBasedRlEnv, std, asset_cfg: SceneEntityCfg
+  ) -> torch.Tensor:
+    del std  # Unused.
+    asset: Entity = env.scene[asset_cfg.name]
+    current_joint_pos = asset.data.joint_pos[:, asset_cfg.joint_ids]
+    desired_joint_pos = self.default_joint_pos[:, asset_cfg.joint_ids]
+    error_squared = torch.square(current_joint_pos - desired_joint_pos)
+    return torch.exp(-torch.mean(error_squared / (self.std**2), dim=1))
+
+
+class electrical_power_cost:
+  """Penalize electrical power consumption of actuators."""
+
+  def __init__(self, cfg: RewardTermCfg, env: ManagerBasedRlEnv):
+    asset: Entity = env.scene[cfg.params["asset_cfg"].name]
+
+    joint_ids, _ = asset.find_joints(
+      cfg.params["asset_cfg"].joint_names,
+    )
+    self._joint_ids = torch.tensor(joint_ids, device=env.device, dtype=torch.long)
+
+  def __call__(self, env: ManagerBasedRlEnv, asset_cfg: SceneEntityCfg) -> torch.Tensor:
+    asset: Entity = env.scene[asset_cfg.name]
+    tau = asset.data.qfrc_actuator[:, self._joint_ids]
+    qd = asset.data.joint_vel[:, self._joint_ids]
+    mech = tau * qd
+    mech_pos = torch.clamp(mech, min=0.0)  # Don't penalize regen.
+    return torch.sum(mech_pos, dim=1)
+
+
+def flat_orientation_l2(
+  env: ManagerBasedRlEnv,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  """Penalize non-flat base orientation."""
+  asset: Entity = env.scene[asset_cfg.name]
+  return torch.sum(torch.square(asset.data.projected_gravity_b[:, :2]), dim=1)
diff --git a/src/mjlab/envs/mdp/terminations.py b/src/mjlab/envs/mdp/terminations.py
new file mode 100644
index 0000000..8f32240
--- /dev/null
+++ b/src/mjlab/envs/mdp/terminations.py
@@ -0,0 +1,49 @@
+"""Useful methods for MDP terminations."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.utils.nan_guard import NanGuard
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+
+_DEFAULT_ASSET_CFG = SceneEntityCfg("robot")
+
+
+def time_out(env: ManagerBasedRlEnv) -> torch.Tensor:
+  """Terminate when the episode length exceeds its maximum."""
+  return env.episode_length_buf >= env.max_episode_length
+
+
+def bad_orientation(
+  env: ManagerBasedRlEnv,
+  limit_angle: float,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+):
+  """Terminate when the asset's orientation exceeds the limit angle."""
+  asset: Entity = env.scene[asset_cfg.name]
+  projected_gravity = asset.data.projected_gravity_b
+  return (
+    torch.acos(torch.clamp(-projected_gravity[:, 2], -1.0, 1.0)).abs() > limit_angle
+  )
+
+
+def root_height_below_minimum(
+  env: ManagerBasedRlEnv,
+  minimum_height: float,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  """Terminate when the asset's root height is below the minimum height."""
+  asset: Entity = env.scene[asset_cfg.name]
+  return asset.data.root_link_pos_w[:, 2] < minimum_height
+
+
+def nan_detection(env: ManagerBasedRlEnv) -> torch.Tensor:
+  """Terminate environments that have NaN/Inf values in their physics state."""
+  return NanGuard.detect_nans(env.sim.data)
diff --git a/src/mjlab/envs/types.py b/src/mjlab/envs/types.py
new file mode 100644
index 0000000..7d49acd
--- /dev/null
+++ b/src/mjlab/envs/types.py
@@ -0,0 +1,6 @@
+from typing import Dict
+
+import torch
+
+VecEnvObs = Dict[str, torch.Tensor | Dict[str, torch.Tensor]]
+VecEnvStepReturn = tuple[VecEnvObs, torch.Tensor, torch.Tensor, torch.Tensor, dict]
diff --git a/src/mjlab/managers/__init__.py b/src/mjlab/managers/__init__.py
new file mode 100644
index 0000000..316f8ed
--- /dev/null
+++ b/src/mjlab/managers/__init__.py
@@ -0,0 +1,37 @@
+"""Environment managers."""
+
+from mjlab.managers.action_manager import ActionManager as ActionManager
+from mjlab.managers.action_manager import ActionTerm as ActionTerm
+from mjlab.managers.action_manager import ActionTermCfg as ActionTermCfg
+from mjlab.managers.command_manager import CommandManager as CommandManager
+from mjlab.managers.command_manager import CommandTerm as CommandTerm
+from mjlab.managers.command_manager import CommandTermCfg as CommandTermCfg
+from mjlab.managers.command_manager import NullCommandManager as NullCommandManager
+from mjlab.managers.curriculum_manager import CurriculumManager as CurriculumManager
+from mjlab.managers.curriculum_manager import CurriculumTermCfg as CurriculumTermCfg
+from mjlab.managers.curriculum_manager import (
+  NullCurriculumManager as NullCurriculumManager,
+)
+from mjlab.managers.event_manager import EventManager as EventManager
+from mjlab.managers.event_manager import EventMode as EventMode
+from mjlab.managers.event_manager import EventTermCfg as EventTermCfg
+from mjlab.managers.manager_base import ManagerBase as ManagerBase
+from mjlab.managers.manager_base import ManagerTermBase as ManagerTermBase
+from mjlab.managers.manager_base import ManagerTermBaseCfg as ManagerTermBaseCfg
+from mjlab.managers.metrics_manager import MetricsManager as MetricsManager
+from mjlab.managers.metrics_manager import MetricsTermCfg as MetricsTermCfg
+from mjlab.managers.metrics_manager import NullMetricsManager as NullMetricsManager
+from mjlab.managers.observation_manager import (
+  ObservationGroupCfg as ObservationGroupCfg,
+)
+from mjlab.managers.observation_manager import ObservationManager as ObservationManager
+from mjlab.managers.observation_manager import ObservationTermCfg as ObservationTermCfg
+from mjlab.managers.recorder_manager import NullRecorderManager as NullRecorderManager
+from mjlab.managers.recorder_manager import RecorderManager as RecorderManager
+from mjlab.managers.recorder_manager import RecorderTerm as RecorderTerm
+from mjlab.managers.recorder_manager import RecorderTermCfg as RecorderTermCfg
+from mjlab.managers.reward_manager import RewardManager as RewardManager
+from mjlab.managers.reward_manager import RewardTermCfg as RewardTermCfg
+from mjlab.managers.scene_entity_config import SceneEntityCfg as SceneEntityCfg
+from mjlab.managers.termination_manager import TerminationManager as TerminationManager
+from mjlab.managers.termination_manager import TerminationTermCfg as TerminationTermCfg
diff --git a/src/mjlab/managers/action_manager.py b/src/mjlab/managers/action_manager.py
new file mode 100644
index 0000000..ab275d3
--- /dev/null
+++ b/src/mjlab/managers/action_manager.py
@@ -0,0 +1,208 @@
+"""Action manager for processing actions sent to the environment."""
+
+from __future__ import annotations
+
+import abc
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Sequence
+
+import torch
+from prettytable import PrettyTable
+
+from mjlab.managers.manager_base import ManagerBase, ManagerTermBase
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+@dataclass(kw_only=True)
+class ActionTermCfg(abc.ABC):
+  """Configuration for an action term.
+
+  Action terms process raw actions from the policy and apply them to entities
+  in the scene (e.g., setting joint positions, velocities, or efforts).
+  """
+
+  entity_name: str
+  """Name of the entity in the scene that this action term controls."""
+
+  clip: dict[str, tuple] | None = None
+  """Optional clipping bounds applied to processed actions (after scale
+  and offset). Dict maps actuator name regex patterns to (min, max)
+  tuples, resolved the same way as ``scale`` and ``offset``."""
+
+  @abc.abstractmethod
+  def build(self, env: ManagerBasedRlEnv) -> ActionTerm:
+    """Build the action term from this config."""
+    raise NotImplementedError
+
+
+class ActionTerm(ManagerTermBase):
+  """Base class for action terms.
+
+  The action term is responsible for processing the raw actions sent to the environment
+  and applying them to the entity managed by the term.
+  """
+
+  def __init__(self, cfg: ActionTermCfg, env: ManagerBasedRlEnv):
+    self.cfg = cfg
+    super().__init__(env)
+    self._entity = self._env.scene[self.cfg.entity_name]
+
+  @property
+  @abc.abstractmethod
+  def action_dim(self) -> int:
+    raise NotImplementedError
+
+  @abc.abstractmethod
+  def process_actions(self, actions: torch.Tensor) -> None:
+    raise NotImplementedError
+
+  @abc.abstractmethod
+  def apply_actions(self) -> None:
+    raise NotImplementedError
+
+  @property
+  @abc.abstractmethod
+  def raw_action(self) -> torch.Tensor:
+    raise NotImplementedError
+
+
+class ActionManager(ManagerBase):
+  """Manages action processing for the environment.
+
+  The action manager aggregates multiple action terms, each controlling a different
+  entity or aspect of the simulation. It splits the policy's action tensor and
+  routes each slice to the appropriate action term.
+  """
+
+  def __init__(self, cfg: dict[str, ActionTermCfg], env: ManagerBasedRlEnv):
+    self.cfg = cfg
+    super().__init__(env=env)
+
+    # Create buffers to store actions.
+    self._action = torch.zeros(
+      (self.num_envs, self.total_action_dim), device=self.device
+    )
+    self._prev_action = torch.zeros_like(self._action)
+    self._prev_prev_action = torch.zeros_like(self._action)
+
+  def __str__(self) -> str:
+    msg = f"<ActionManager> contains {len(self._term_names)} active terms.\n"
+    table = PrettyTable()
+    table.title = f"Active Action Terms (shape: {self.total_action_dim})"
+    table.field_names = ["Index", "Name", "Dimension"]
+    table.align["Name"] = "l"
+    table.align["Dimension"] = "r"
+    for index, (name, term) in enumerate(self._terms.items()):
+      table.add_row([index, name, term.action_dim])
+    msg += table.get_string()
+    msg += "\n"
+    return msg
+
+  # Properties.
+
+  @property
+  def total_action_dim(self) -> int:
+    return sum(self.action_term_dim)
+
+  @property
+  def action_term_dim(self) -> list[int]:
+    return [term.action_dim for term in self._terms.values()]
+
+  @property
+  def action(self) -> torch.Tensor:
+    """Raw policy output from the current step, before per-term
+    scale/offset. Shape: ``(num_envs, total_action_dim)``."""
+    return self._action
+
+  @property
+  def prev_action(self) -> torch.Tensor:
+    """Raw policy output from the previous step, before per-term
+    scale/offset. Shape: ``(num_envs, total_action_dim)``."""
+    return self._prev_action
+
+  @property
+  def prev_prev_action(self) -> torch.Tensor:
+    """Raw policy output from two steps ago, before per-term
+    scale/offset. Shape: ``(num_envs, total_action_dim)``."""
+    return self._prev_prev_action
+
+  @property
+  def active_terms(self) -> list[str]:
+    return self._term_names
+
+  # Methods.
+
+  def get_term(self, name: str) -> ActionTerm:
+    return self._terms[name]
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> dict[str, float]:
+    if env_ids is None:
+      env_ids = slice(None)
+    # Reset action history.
+    self._prev_action[env_ids] = 0.0
+    self._prev_prev_action[env_ids] = 0.0
+    self._action[env_ids] = 0.0
+    # Reset action terms.
+    for term in self._terms.values():
+      term.reset(env_ids=env_ids)
+    return {}
+
+  def process_action(self, action: torch.Tensor) -> None:
+    """Store the raw policy output and route slices to each action term.
+
+    Called once per policy step. The raw action tensor is saved into the
+    history buffers (``action``, ``prev_action``, ``prev_prev_action``) *before*
+    any per-term scale/offset is applied. Each term then receives its slice and
+    independently applies its own affine transformation via
+    :meth:`ActionTerm.process_actions`.
+    """
+    if self.total_action_dim != action.shape[1]:
+      raise ValueError(
+        f"Invalid action shape, expected: {self.total_action_dim},"
+        f" received: {action.shape[1]}."
+      )
+    # Shift history: prev_prev ← prev ← current ← new.
+    self._prev_prev_action[:] = self._prev_action
+    self._prev_action[:] = self._action
+    self._action[:] = action.to(self.device)
+    # Split the flat action vector and route each slice to its term.
+    idx = 0
+    for term in self._terms.values():
+      term_actions = action[:, idx : idx + term.action_dim]
+      term.process_actions(term_actions)
+      idx += term.action_dim
+
+  def apply_action(self) -> None:
+    """Write processed actions to entity actuator targets.
+
+    Called on every decimation substep (physics step), not just once per policy
+    step. Each term writes its most recently processed targets to the simulation.
+    """
+    for term in self._terms.values():
+      term.apply_actions()
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    terms = []
+    idx = 0
+    for name, term in self._terms.items():
+      term_actions = self._action[env_idx, idx : idx + term.action_dim].cpu()
+      terms.append((name, term_actions.tolist()))
+      idx += term.action_dim
+    return terms
+
+  def _prepare_terms(self):
+    self._term_names: list[str] = list()
+    self._terms: dict[str, ActionTerm] = dict()
+
+    for term_name, term_cfg in self.cfg.items():
+      term_cfg: ActionTermCfg | None
+      if term_cfg is None:
+        print(f"term: {term_name} set to None, skipping...")
+        continue
+      term = term_cfg.build(self._env)
+      self._term_names.append(term_name)
+      self._terms[term_name] = term
diff --git a/src/mjlab/managers/command_manager.py b/src/mjlab/managers/command_manager.py
new file mode 100644
index 0000000..950a34b
--- /dev/null
+++ b/src/mjlab/managers/command_manager.py
@@ -0,0 +1,373 @@
+"""Command manager for generating and updating commands."""
+
+from __future__ import annotations
+
+import abc
+import inspect
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Sequence
+
+import torch
+from prettytable import PrettyTable
+
+from mjlab.managers.manager_base import ManagerBase, ManagerTermBase
+
+if TYPE_CHECKING:
+  import viser
+
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+  from mjlab.viewer.debug_visualizer import DebugVisualizer
+
+
+@dataclass(kw_only=True)
+class CommandTermCfg(abc.ABC):
+  """Configuration for a command generator term.
+
+  Command terms generate goal commands for the agent (e.g., target velocity,
+  target position). Commands are automatically resampled at configurable
+  intervals and can track metrics for logging.
+  """
+
+  resampling_time_range: tuple[float, float]
+  """Time range in seconds for command resampling. When the timer expires, a new
+  command is sampled and the timer is reset to a value uniformly drawn from
+  ``[min, max]``. Set both values equal for fixed-interval resampling."""
+
+  debug_vis: bool = False
+  """Whether to enable debug visualization for this command term. When True,
+  the command term's ``_debug_vis_impl`` method is called each frame to render
+  visual aids (e.g., velocity arrows, target markers)."""
+
+  @abc.abstractmethod
+  def build(self, env: ManagerBasedRlEnv) -> CommandTerm:
+    """Build the command term from this config."""
+    raise NotImplementedError
+
+
+class CommandTerm(ManagerTermBase):
+  """Base class for command terms."""
+
+  def __init__(self, cfg: CommandTermCfg, env: ManagerBasedRlEnv):
+    self.cfg = cfg
+    super().__init__(env)
+    self._check_update_command_signature()
+    self.metrics = dict()
+    self.time_left = torch.zeros(self.num_envs, device=self.device)
+    self.command_counter = torch.zeros(
+      self.num_envs, device=self.device, dtype=torch.long
+    )
+    self._debug_vis_enabled: bool = True
+
+  def debug_vis(self, visualizer: "DebugVisualizer") -> None:
+    if self.cfg.debug_vis and self._debug_vis_enabled:
+      self._debug_vis_impl(visualizer)
+
+  def _debug_vis_impl(self, visualizer: "DebugVisualizer") -> None:
+    pass
+
+  def create_gui(
+    self,
+    name: str,
+    server: viser.ViserServer,
+    get_env_idx: Callable[[], int],
+    on_change: Callable[[], None] | None = None,
+    request_action: Callable[[str, Any], None] | None = None,
+  ) -> None:
+    """Create interactive GUI controls for this command term.
+
+    Override in subclasses to add task-specific controls (e.g., velocity sliders) to
+    the Viser viewer. Called once during viewer setup.
+
+    The *name* argument is the term's key in the command manager config (e.g.,
+    ``"twist"``).
+    """
+
+  def on_viewer_pause(self, paused: bool) -> None:
+    """Called when the viewer pause state changes."""
+
+  def apply_gui_reset(self, env_ids: torch.Tensor) -> bool:
+    """Apply GUI-selected state as an env reset override.
+
+    Returns True if this term wrote state to sim.
+    """
+    return False
+
+  @property
+  @abc.abstractmethod
+  def command(self):
+    raise NotImplementedError
+
+  def reset(self, env_ids: torch.Tensor | slice | None) -> dict[str, float]:
+    assert isinstance(env_ids, torch.Tensor)
+    extras = {}
+    for metric_name, metric_value in self.metrics.items():
+      extras[metric_name] = torch.mean(metric_value[env_ids]).item()
+      metric_value[env_ids] = 0.0
+    self.command_counter[env_ids] = 0
+    self._resample(env_ids)
+    return extras
+
+  def compute(
+    self, dt: float | torch.Tensor, env_ids: torch.Tensor | None = None
+  ) -> None:
+    """Advance the command state by dt.
+
+    With env_ids=None (the per-step path) all envs are updated; with env_ids
+    (the reset path) timers and the command update are scoped to those envs.
+    Metrics are always refreshed.
+
+    dt may be a scalar (all envs) or a per-env tensor (auto-reset path,
+    where freshly reset envs get zero to keep their timers full). A tensor
+    dt requires env_ids=None.
+    """
+    self._update_metrics()
+    if env_ids is None:
+      self.time_left -= dt
+      resample_env_ids = (self.time_left <= 0.0).nonzero().flatten()
+    else:
+      assert not isinstance(dt, torch.Tensor)
+      self.time_left[env_ids] -= dt
+      resample_env_ids = env_ids[self.time_left[env_ids] <= 0.0]
+    if len(resample_env_ids) > 0:
+      self._resample(resample_env_ids)
+    self._update_command(env_ids)
+
+  def _check_update_command_signature(self) -> None:
+    """Fail fast with a migration hint for terms with the old signature."""
+    try:
+      sig = inspect.signature(self._update_command)
+    except (TypeError, ValueError):
+      return
+    if len(sig.parameters) == 0:
+      raise TypeError(
+        f"{type(self).__name__}._update_command must accept env_ids: "
+        "_update_command(self, env_ids: torch.Tensor | None). It receives "
+        "None on the per-step update and the reset env ids on reset(); "
+        "scope per-step state advances to env_ids."
+      )
+
+  def _resample(self, env_ids: torch.Tensor) -> None:
+    if len(env_ids) != 0:
+      self.time_left[env_ids] = self.time_left[env_ids].uniform_(
+        *self.cfg.resampling_time_range
+      )
+      self._resample_command(env_ids)
+      self.command_counter[env_ids] += 1
+
+  @abc.abstractmethod
+  def _update_metrics(self) -> None:
+    """Update the metrics based on the current state."""
+    raise NotImplementedError
+
+  @abc.abstractmethod
+  def _resample_command(self, env_ids: torch.Tensor) -> None:
+    """Resample the command for the specified environments."""
+    raise NotImplementedError
+
+  @abc.abstractmethod
+  def _update_command(self, env_ids: torch.Tensor | None) -> None:
+    """Update the command based on the current state.
+
+    env_ids is None on the per-step update (all envs) and the reset env ids on reset().
+    Scope per-step state advances (e.g. a motion frame index) to env_ids; pure
+    functions of the current state may ignore it.
+    """
+    raise NotImplementedError
+
+
+class CommandManager(ManagerBase):
+  """Manages command generation for the environment.
+
+  The command manager generates and updates goal commands for the agent (e.g.,
+  target velocity, target position). Commands are resampled at configurable
+  intervals and can track metrics for logging.
+  """
+
+  _env: ManagerBasedRlEnv
+
+  def __init__(self, cfg: dict[str, CommandTermCfg], env: ManagerBasedRlEnv):
+    self._terms: dict[str, CommandTerm] = dict()
+
+    self.cfg = cfg
+    super().__init__(env)
+    self._commands = dict()
+
+  def __str__(self) -> str:
+    msg = f"<CommandManager> contains {len(self._terms.values())} active terms.\n"
+    table = PrettyTable()
+    table.title = "Active Command Terms"
+    table.field_names = ["Index", "Name", "Type"]
+    table.align["Name"] = "l"
+    for index, (name, term) in enumerate(self._terms.items()):
+      table.add_row([index, name, term.__class__.__name__])
+    msg += table.get_string()
+    msg += "\n"
+    return msg
+
+  def debug_vis(self, visualizer: "DebugVisualizer") -> None:
+    for term in self._terms.values():
+      term.debug_vis(visualizer)
+
+  def create_gui(
+    self,
+    server: viser.ViserServer,
+    get_env_idx: Callable[[], int],
+    on_change: Callable[[], None] | None = None,
+    request_action: Callable[[str, Any], None] | None = None,
+  ) -> None:
+    """Let each command term create its GUI controls."""
+    for name, term in self._terms.items():
+      term.create_gui(
+        name,
+        server,
+        get_env_idx,
+        on_change=on_change,
+        request_action=request_action,
+      )
+
+  def on_viewer_pause(self, paused: bool) -> None:
+    """Notify all command terms of viewer pause state change."""
+    for term in self._terms.values():
+      term.on_viewer_pause(paused)
+
+  def apply_gui_reset(self, env_ids: torch.Tensor) -> bool:
+    """Apply GUI-selected state from all terms. Returns True if any applied."""
+    applied = False
+    for term in self._terms.values():
+      applied |= term.apply_gui_reset(env_ids)
+    return applied
+
+  def create_debug_vis_gui(
+    self,
+    server: viser.ViserServer,
+    on_change: Callable[[], None] | None = None,
+  ) -> None:
+    """Add per-term debug visualization checkboxes."""
+    vis_terms = {name: term for name, term in self._terms.items() if term.cfg.debug_vis}
+    if not vis_terms:
+      return
+    for name, term in vis_terms.items():
+      cb = server.gui.add_checkbox(
+        name.capitalize(),
+        initial_value=term._debug_vis_enabled,
+      )
+
+      def _on_update(_ev, _term: CommandTerm = term, _cb=cb) -> None:
+        _term._debug_vis_enabled = _cb.value
+        if on_change is not None:
+          on_change()
+
+      cb.on_update(_on_update)
+
+  # Properties.
+
+  @property
+  def active_terms(self) -> list[str]:
+    return list(self._terms.keys())
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    terms = []
+    idx = 0
+    for name, term in self._terms.items():
+      terms.append((name, term.command[env_idx].cpu().tolist()))
+      idx += term.command.shape[1]
+    return terms
+
+  def reset(self, env_ids: torch.Tensor | None) -> dict[str, torch.Tensor]:
+    extras = {}
+    for name, term in self._terms.items():
+      metrics = term.reset(env_ids=env_ids)
+      for metric_name, metric_value in metrics.items():
+        extras[f"Metrics/{name}/{metric_name}"] = metric_value
+    return extras
+
+  def compute(self, dt: float | torch.Tensor, env_ids: torch.Tensor | None = None):
+    for term in self._terms.values():
+      term.compute(dt, env_ids)
+
+  def get_command(self, name: str) -> torch.Tensor:
+    return self._terms[name].command
+
+  def get_term(self, name: str) -> CommandTerm:
+    return self._terms[name]
+
+  def get_term_cfg(self, name: str) -> CommandTermCfg:
+    return self.cfg[name]
+
+  def _prepare_terms(self):
+    for term_name, term_cfg in self.cfg.items():
+      term_cfg: CommandTermCfg | None
+      if term_cfg is None:
+        print(f"term: {term_name} set to None, skipping...")
+        continue
+      term = term_cfg.build(self._env)
+      if not isinstance(term, CommandTerm):
+        raise TypeError(
+          f"Returned object for the term {term_name} is not of type CommandType."
+        )
+      self._terms[term_name] = term
+
+
+class NullCommandManager:
+  """Placeholder for absent command manager that safely no-ops all operations."""
+
+  def __init__(self):
+    self.active_terms: list[str] = []
+    self._terms: dict[str, Any] = {}
+    self.cfg = None
+
+  def __str__(self) -> str:
+    return "<NullCommandManager> (inactive)"
+
+  def __repr__(self) -> str:
+    return "NullCommandManager()"
+
+  def debug_vis(self, visualizer: "DebugVisualizer") -> None:
+    pass
+
+  def create_gui(
+    self,
+    server: viser.ViserServer,
+    get_env_idx: Callable[[], int],
+    on_change: Callable[[], None] | None = None,
+    request_action: Callable[[str, Any], None] | None = None,
+  ) -> None:
+    pass
+
+  def on_viewer_pause(self, paused: bool) -> None:
+    pass
+
+  def apply_gui_reset(self, env_ids: torch.Tensor) -> bool:
+    return False
+
+  def create_debug_vis_gui(
+    self,
+    server: viser.ViserServer,
+    on_change: Callable[[], None] | None = None,
+  ) -> None:
+    pass
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    return []
+
+  def reset(self, env_ids: torch.Tensor | None = None) -> dict[str, torch.Tensor]:
+    return {}
+
+  def compute(
+    self, dt: float | torch.Tensor, env_ids: torch.Tensor | None = None
+  ) -> None:
+    pass
+
+  def get_command(self, name: str) -> None:
+    return None
+
+  def get_term(self, name: str) -> None:
+    return None
+
+  def get_term_cfg(self, name: str) -> None:
+    return None
diff --git a/src/mjlab/managers/curriculum_manager.py b/src/mjlab/managers/curriculum_manager.py
new file mode 100644
index 0000000..cafd2d2
--- /dev/null
+++ b/src/mjlab/managers/curriculum_manager.py
@@ -0,0 +1,155 @@
+"""Curriculum manager for updating environment quantities subject to a training curriculum."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Sequence
+
+import torch
+from prettytable import PrettyTable
+
+from mjlab.managers.manager_base import ManagerBase, ManagerTermBaseCfg
+
+if TYPE_CHECKING:
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+
+
+@dataclass(kw_only=True)
+class CurriculumTermCfg(ManagerTermBaseCfg):
+  """Configuration for a curriculum term.
+
+  Curriculum terms modify environment parameters during training to implement
+  curriculum learning strategies (e.g., gradually increasing task difficulty).
+  """
+
+  pass
+
+
+class CurriculumManager(ManagerBase):
+  """Manages curriculum learning for the environment.
+
+  The curriculum manager updates environment parameters during training based
+  on agent performance. Each term can modify different aspects of the task
+  difficulty (e.g., terrain complexity, command ranges).
+  """
+
+  _env: ManagerBasedRlEnv
+
+  def __init__(self, cfg: dict[str, CurriculumTermCfg], env: ManagerBasedRlEnv):
+    self._term_names: list[str] = list()
+    self._term_cfgs: list[CurriculumTermCfg] = list()
+    self._class_term_cfgs: list[CurriculumTermCfg] = list()
+
+    self.cfg = deepcopy(cfg)
+    super().__init__(env)
+
+    self._curriculum_state = dict()
+    for term_name in self._term_names:
+      self._curriculum_state[term_name] = None
+
+  def __str__(self) -> str:
+    msg = f"<CurriculumManager> contains {len(self._term_names)} active terms.\n"
+    table = PrettyTable()
+    table.title = "Active Curriculum Terms"
+    table.field_names = ["Index", "Name"]
+    table.align["Name"] = "l"
+    for index, name in enumerate(self._term_names):
+      table.add_row([index, name])
+    msg += table.get_string()
+    msg += "\n"
+    return msg
+
+  # Properties.
+
+  @property
+  def active_terms(self) -> list[str]:
+    return self._term_names
+
+  # Methods.
+
+  def get_term_cfg(self, term_name: str) -> CurriculumTermCfg:
+    if term_name not in self._term_names:
+      raise ValueError(f"Term '{term_name}' not found in active terms.")
+    return self._term_cfgs[self._term_names.index(term_name)]
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    terms = []
+    for term_name, term_state in self._curriculum_state.items():
+      if term_state is not None:
+        data = []
+        if isinstance(term_state, dict):
+          for _key, value in term_state.items():
+            if isinstance(value, torch.Tensor):
+              value = value.item()
+            data.append(value)
+        else:
+          if isinstance(term_state, torch.Tensor):
+            term_state = term_state.item()
+          data.append(term_state)
+        terms.append((term_name, data))
+    return terms
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> dict[str, float]:
+    extras = {}
+    for term_name, term_state in self._curriculum_state.items():
+      if term_state is not None:
+        if isinstance(term_state, dict):
+          for key, value in term_state.items():
+            if isinstance(value, torch.Tensor):
+              value = value.item()
+            extras[f"Curriculum/{term_name}/{key}"] = value
+        else:
+          if isinstance(term_state, torch.Tensor):
+            term_state = term_state.item()
+          extras[f"Curriculum/{term_name}"] = term_state
+    for term_cfg in self._class_term_cfgs:
+      term_cfg.func.reset(env_ids=env_ids)
+    return extras
+
+  def compute(self, env_ids: torch.Tensor | slice | None = None):
+    if env_ids is None:
+      env_ids = slice(None)
+    for name, term_cfg in zip(self._term_names, self._term_cfgs, strict=False):
+      state = term_cfg.func(self._env, env_ids, **term_cfg.params)
+      self._curriculum_state[name] = state
+
+  def _prepare_terms(self):
+    for term_name, term_cfg in self.cfg.items():
+      term_cfg: CurriculumTermCfg | None
+      if term_cfg is None:
+        print(f"term: {term_name} set to None, skipping...")
+        continue
+      self._resolve_common_term_cfg(term_name, term_cfg)
+      self._term_names.append(term_name)
+      self._term_cfgs.append(term_cfg)
+      if hasattr(term_cfg.func, "reset") and callable(term_cfg.func.reset):
+        self._class_term_cfgs.append(term_cfg)
+
+
+class NullCurriculumManager:
+  """Placeholder for absent curriculum manager that safely no-ops all operations."""
+
+  def __init__(self):
+    self.active_terms: list[str] = []
+    self._curriculum_state: dict[str, Any] = {}
+    self.cfg = None
+
+  def __str__(self) -> str:
+    return "<NullCurriculumManager> (inactive)"
+
+  def __repr__(self) -> str:
+    return "NullCurriculumManager()"
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    return []
+
+  def reset(self, env_ids: torch.Tensor | None = None) -> dict[str, float]:
+    return {}
+
+  def compute(self, env_ids: torch.Tensor | None = None) -> None:
+    pass
diff --git a/src/mjlab/managers/event_manager.py b/src/mjlab/managers/event_manager.py
new file mode 100644
index 0000000..6215b09
--- /dev/null
+++ b/src/mjlab/managers/event_manager.py
@@ -0,0 +1,390 @@
+"""Event manager for orchestrating operations based on different simulation events."""
+
+from __future__ import annotations
+
+import enum
+from collections.abc import Callable
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal
+
+import torch
+from prettytable import PrettyTable
+
+from mjlab.managers.manager_base import ManagerBase, ManagerTermBaseCfg
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+  from mjlab.viewer.debug_visualizer import DebugVisualizer
+
+F = Callable[..., None]
+
+EventMode = Literal["startup", "reset", "interval", "step"]
+
+
+class RecomputeLevel(enum.IntEnum):
+  """Recomputation level for derived model constants after domain randomization.
+
+  Higher values are more expensive and recompute a superset of the lower levels.
+
+  .. note::
+
+    All levels above ``none`` are expensive (forward kinematics, mass matrix
+    factorization, etc.). Prefer ``startup`` or ``reset`` event modes for
+    DR terms that require recomputation.
+  """
+
+  none = 0
+  """No recomputation needed (e.g. geom_friction, dof_damping)."""
+
+  set_const_fixed = 1
+  """Recompute ``body_subtreemass``. Use after modifying ``body_gravcomp``."""
+
+  set_const_0 = 2
+  """Recompute ``dof_invweight0``, ``body_invweight0``, ``tendon_length0``,
+  ``tendon_invweight0``, and ``actuator_acc0``. Use after modifying
+  ``dof_armature``, ``body_inertia``, ``body_pos``, ``body_quat``, or ``qpos0``."""
+
+  set_const = 3
+  """Full recomputation (superset of all lower levels). Use after modifying
+  ``body_mass`` or ``body_ipos``."""
+
+
+_DERIVED_FIELDS: dict[RecomputeLevel, tuple[str, ...]] = {
+  RecomputeLevel.none: (),
+  RecomputeLevel.set_const_fixed: ("body_subtreemass",),
+  RecomputeLevel.set_const_0: (
+    "dof_invweight0",
+    "body_invweight0",
+    "tendon_length0",
+    "tendon_invweight0",
+    "actuator_acc0",
+  ),
+}
+_DERIVED_FIELDS[RecomputeLevel.set_const] = (
+  _DERIVED_FIELDS[RecomputeLevel.set_const_fixed]
+  + _DERIVED_FIELDS[RecomputeLevel.set_const_0]
+)
+
+
+def requires_model_fields(
+  *fields: str, recompute: RecomputeLevel = RecomputeLevel.none
+) -> Callable[[F], F]:
+  """Mark an event function as requiring specific model fields expanded per-world.
+
+  Fields listed here are registered in ``EventManager.domain_randomization_fields``
+  so that ``sim.expand_model_fields()`` allocates real per-world memory for them.
+
+  Args:
+    *fields: Model field names to expand per-world.
+    recompute: Recomputation level after modifying these fields.
+      Derived fields are automatically appended to the model_fields list.
+
+  Example::
+
+    @requires_model_fields("body_mass", recompute=RecomputeLevel.set_const)
+    def body_mass(env, env_ids, ...):
+      ...
+  """
+  derived = _DERIVED_FIELDS[recompute]
+  all_fields = fields + tuple(f for f in derived if f not in fields)
+
+  def decorator(func: F) -> F:
+    func.model_fields = all_fields  # type: ignore[attr-defined]
+    func.recompute = recompute  # type: ignore[attr-defined]
+    return func
+
+  return decorator
+
+
+@dataclass(kw_only=True)
+class EventTermCfg(ManagerTermBaseCfg):
+  """Configuration for an event term.
+
+  Event terms trigger operations at specific simulation events. They're commonly
+  used for domain randomization, state resets, and periodic perturbations.
+
+  The four modes determine when the event fires:
+
+  - ``"startup"``: Once when the environment initializes. Use for parameters that
+    should be randomized per-environment but stay constant within an episode (e.g.,
+    domain randomization).
+
+  - ``"reset"``: On every episode reset. Use for parameters that should vary between
+    episodes (e.g., initial robot pose, domain randomization).
+
+  - ``"interval"``: Periodically during simulation, controlled by ``interval_range_s``.
+    Use for perturbations that should happen during episodes (e.g., pushing the robot,
+    external disturbances).
+
+  - ``"step"``: Every environment step, unconditionally on all envs. Use for terms that
+    manage per-step state such as force lifetimes (e.g., ``apply_body_impulse``).
+  """
+
+  mode: EventMode
+  """When the event triggers: ``"startup"`` (once at init), ``"reset"`` (every
+  episode), ``"interval"`` (periodically during simulation), or ``"step"`` (every
+  environment step)."""
+
+  interval_range_s: tuple[float, float] | None = None
+  """Time range in seconds for interval mode. The next trigger time is uniformly
+  sampled from ``[min, max]``. Required when ``mode="interval"``."""
+
+  is_global_time: bool = False
+  """Whether all environments share the same timer. If True, all envs trigger
+  simultaneously. If False (default), each env has an independent timer that
+  resets on episode reset. Only applies to ``mode="interval"``."""
+
+  min_step_count_between_reset: int = 0
+  """Minimum environment steps between triggers. Prevents the event from firing
+  too frequently when episodes reset rapidly. Only applies to ``mode="reset"``.
+  Set to 0 (default) to trigger on every reset."""
+
+
+class EventManager(ManagerBase):
+  """Manages event-based operations for the environment.
+
+  The event manager triggers operations at different simulation events: startup
+  (once at initialization), reset (on episode reset), or interval (periodically
+  during simulation). Common uses include domain randomization and state resets.
+  """
+
+  _env: ManagerBasedRlEnv
+
+  def __init__(self, cfg: dict[str, EventTermCfg], env: ManagerBasedRlEnv):
+    self.cfg = deepcopy(cfg)
+    self._mode_term_names: dict[EventMode, list[str]] = dict()
+    self._mode_term_cfgs: dict[EventMode, list[EventTermCfg]] = dict()
+    self._mode_class_term_cfgs: dict[EventMode, list[EventTermCfg]] = dict()
+    self._domain_randomization_fields: list[str] = list()
+
+    super().__init__(env=env)
+
+  def __str__(self) -> str:
+    msg = f"<EventManager> contains {len(self._mode_term_names)} active terms.\n"
+    for mode in self._mode_term_names:
+      table = PrettyTable()
+      table.title = f"Active Event Terms in Mode: '{mode}'"
+      if mode == "interval":
+        table.field_names = ["Index", "Name", "Interval time range (s)"]
+        table.align["Name"] = "l"
+        for index, (name, cfg) in enumerate(
+          zip(self._mode_term_names[mode], self._mode_term_cfgs[mode], strict=False)
+        ):
+          table.add_row([index, name, cfg.interval_range_s])
+      else:
+        table.field_names = ["Index", "Name"]
+        table.align["Name"] = "l"
+        for index, name in enumerate(self._mode_term_names[mode]):
+          table.add_row([index, name])
+      msg += table.get_string()
+      msg += "\n"
+    if self._domain_randomization_fields:
+      table = PrettyTable()
+      table.title = "Domain Randomization Fields"
+      table.field_names = ["Index", "Field Name"]
+      table.align["Field Name"] = "l"
+      for index, field in enumerate(self._domain_randomization_fields):
+        table.add_row([index, field])
+      msg += table.get_string()
+      msg += "\n"
+    return msg
+
+  # Properties.
+
+  @property
+  def active_terms(self) -> dict[EventMode, list[str]]:
+    return self._mode_term_names
+
+  @property
+  def available_modes(self) -> list[EventMode]:
+    return list(self._mode_term_names.keys())
+
+  @property
+  def domain_randomization_fields(self) -> tuple[str, ...]:
+    return tuple(self._domain_randomization_fields)
+
+  # Methods.
+
+  def get_term_cfg(self, term_name: str) -> EventTermCfg:
+    """Get the configuration of a specific event term by name."""
+    for mode in self._mode_term_names:
+      if term_name in self._mode_term_names[mode]:
+        index = self._mode_term_names[mode].index(term_name)
+        return self._mode_term_cfgs[mode][index]
+    raise ValueError(f"Event term '{term_name}' not found in active terms.")
+
+  def reset(self, env_ids: torch.Tensor | None = None):
+    for mode_cfg in self._mode_class_term_cfgs.values():
+      for term_cfg in mode_cfg:
+        term_cfg.func.reset(env_ids=env_ids)
+    if env_ids is None:
+      num_envs = self._env.num_envs
+      ids: torch.Tensor | slice = slice(None)
+    else:
+      num_envs = len(env_ids)
+      ids = env_ids
+    # Iterate the full interval term list: _interval_term_time_left is parallel
+    # to _mode_term_cfgs["interval"], not the class-only subset.
+    if "interval" in self._mode_term_cfgs:
+      for index, term_cfg in enumerate(self._mode_term_cfgs["interval"]):
+        if not term_cfg.is_global_time:
+          assert term_cfg.interval_range_s is not None
+          lower, upper = term_cfg.interval_range_s
+          sampled_interval = (
+            torch.rand(num_envs, device=self.device) * (upper - lower) + lower
+          )
+          self._interval_term_time_left[index][ids] = sampled_interval
+    return {}
+
+  def apply(
+    self,
+    mode: EventMode,
+    env_ids: torch.Tensor | slice | None = None,
+    dt: float | None = None,
+    global_env_step_count: int | None = None,
+  ):
+    if mode == "interval" and dt is None:
+      raise ValueError(
+        f"Event mode '{mode}' requires the time-step of the environment."
+      )
+    if mode == "interval" and env_ids is not None:
+      raise ValueError(
+        f"Event mode '{mode}' does not require environment indices. This is an undefined behavior"
+        " as the environment indices are computed based on the time left for each environment."
+      )
+    if mode == "reset" and global_env_step_count is None:
+      raise ValueError(
+        f"Event mode '{mode}' requires the total number of environment steps to be provided."
+      )
+    if mode == "step" and dt is None:
+      raise ValueError(
+        f"Event mode '{mode}' requires the time-step of the environment."
+      )
+
+    strongest_fired = RecomputeLevel.none
+
+    for index, term_cfg in enumerate(self._mode_term_cfgs[mode]):
+      fired = False
+      if mode == "interval":
+        time_left = self._interval_term_time_left[index]
+        assert dt is not None
+        time_left -= dt
+        if term_cfg.is_global_time:
+          if time_left < 1e-6:
+            assert term_cfg.interval_range_s is not None
+            lower, upper = term_cfg.interval_range_s
+            sampled_interval = torch.rand(1) * (upper - lower) + lower
+            self._interval_term_time_left[index][:] = sampled_interval
+            term_cfg.func(self._env, None, **term_cfg.params)
+            fired = True
+        else:
+          valid_env_ids = (time_left < 1e-6).nonzero().flatten()
+          if len(valid_env_ids) > 0:
+            assert term_cfg.interval_range_s is not None
+            lower, upper = term_cfg.interval_range_s
+            sampled_time = (
+              torch.rand(len(valid_env_ids), device=self.device) * (upper - lower)
+              + lower
+            )
+            self._interval_term_time_left[index][valid_env_ids] = sampled_time
+            term_cfg.func(self._env, valid_env_ids, **term_cfg.params)
+            fired = True
+      elif mode == "step":
+        term_cfg.func(self._env, None, **term_cfg.params)
+        fired = True
+      elif mode == "reset":
+        assert global_env_step_count is not None
+        # Reset events require concrete indices: callers (e.g. ManagerBasedRlEnv)
+        # resolve None to all environments upstream. Enforce that here so a future
+        # caller passing None fails loudly instead of leaking a slice into event
+        # functions, which only understand None or a tensor.
+        assert env_ids is not None, "reset events require concrete env_ids, got None"
+        min_step_count = term_cfg.min_step_count_between_reset
+        if min_step_count == 0:
+          self._reset_term_last_triggered_step_id[index][env_ids] = (
+            global_env_step_count
+          )
+          self._reset_term_last_triggered_once[index][env_ids] = True
+          term_cfg.func(self._env, env_ids, **term_cfg.params)
+          fired = True
+        else:
+          last_triggered_step = self._reset_term_last_triggered_step_id[index][env_ids]
+          triggered_at_least_once = self._reset_term_last_triggered_once[index][env_ids]
+          steps_since_triggered = global_env_step_count - last_triggered_step
+          valid_trigger = steps_since_triggered >= min_step_count
+          valid_trigger |= (last_triggered_step == 0) & ~triggered_at_least_once
+          if isinstance(env_ids, torch.Tensor):
+            valid_env_ids = env_ids[valid_trigger]
+          else:
+            valid_env_ids = valid_trigger.nonzero().flatten()
+          if len(valid_env_ids) > 0:
+            self._reset_term_last_triggered_once[index][valid_env_ids] = True
+            self._reset_term_last_triggered_step_id[index][valid_env_ids] = (
+              global_env_step_count
+            )
+            term_cfg.func(self._env, valid_env_ids, **term_cfg.params)
+            fired = True
+      else:
+        term_cfg.func(self._env, env_ids, **term_cfg.params)
+        fired = True
+
+      if fired:
+        level = getattr(term_cfg.func, "recompute", RecomputeLevel.none)
+        strongest_fired = max(strongest_fired, level)
+
+    if strongest_fired != RecomputeLevel.none:
+      self._env.sim.recompute_constants(strongest_fired)
+
+  def debug_vis(self, visualizer: "DebugVisualizer") -> None:
+    """Delegate debug visualization to class-based event terms."""
+    for mode_cfgs in self._mode_class_term_cfgs.values():
+      for term_cfg in mode_cfgs:
+        if hasattr(term_cfg.func, "debug_vis"):
+          term_cfg.func.debug_vis(visualizer)
+
+  def _prepare_terms(self) -> None:
+    self._interval_term_time_left: list[torch.Tensor] = list()
+    self._reset_term_last_triggered_step_id: list[torch.Tensor] = list()
+    self._reset_term_last_triggered_once: list[torch.Tensor] = list()
+
+    for term_name, term_cfg in self.cfg.items():
+      term_cfg: EventTermCfg | None
+      if term_cfg is None:
+        print(f"term: {term_name} set to None, skipping...")
+        continue
+      self._resolve_common_term_cfg(term_name, term_cfg)
+      if term_cfg.mode not in self._mode_term_names:
+        self._mode_term_names[term_cfg.mode] = list()
+        self._mode_term_cfgs[term_cfg.mode] = list()
+        self._mode_class_term_cfgs[term_cfg.mode] = list()
+      self._mode_term_names[term_cfg.mode].append(term_name)
+      self._mode_term_cfgs[term_cfg.mode].append(term_cfg)
+      if hasattr(term_cfg.func, "reset") and callable(term_cfg.func.reset):
+        self._mode_class_term_cfgs[term_cfg.mode].append(term_cfg)
+      if term_cfg.mode == "interval":
+        if term_cfg.interval_range_s is None:
+          raise ValueError(
+            f"Event term '{term_name}' has mode 'interval' but 'interval_range_s' is not specified."
+          )
+        if term_cfg.is_global_time:
+          lower, upper = term_cfg.interval_range_s
+          time_left = torch.rand(1) * (upper - lower) + lower
+          self._interval_term_time_left.append(time_left)
+        else:
+          lower, upper = term_cfg.interval_range_s
+          time_left = (
+            torch.rand(self.num_envs, device=self.device) * (upper - lower) + lower
+          )
+          self._interval_term_time_left.append(time_left)
+      elif term_cfg.mode == "reset":
+        step_count = torch.zeros(self.num_envs, device=self.device, dtype=torch.int32)
+        self._reset_term_last_triggered_step_id.append(step_count)
+        no_trigger = torch.zeros(self.num_envs, device=self.device, dtype=torch.bool)
+        self._reset_term_last_triggered_once.append(no_trigger)
+
+      func = term_cfg.func
+      if hasattr(func, "model_fields"):
+        for field in func.model_fields:
+          if field not in self._domain_randomization_fields:
+            self._domain_randomization_fields.append(field)
diff --git a/src/mjlab/managers/manager_base.py b/src/mjlab/managers/manager_base.py
new file mode 100644
index 0000000..364bd45
--- /dev/null
+++ b/src/mjlab/managers/manager_base.py
@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+import abc
+import inspect
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+import torch
+
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+@dataclass
+class ManagerTermBaseCfg:
+  """Base configuration for manager terms.
+
+  This is the base config for terms in observation, reward, termination, curriculum,
+  and event managers. It provides a common interface for specifying a callable
+  and its parameters.
+
+  The ``func`` field accepts either a function or a class:
+
+  **Function-based terms** are simpler and suitable for stateless computations:
+
+  .. code-block:: python
+
+      RewardTermCfg(func=mdp.joint_torques_l2, weight=-0.01)
+
+  **Class-based terms** are instantiated with ``(cfg, env)`` and useful when you need
+  to:
+
+  - Cache computed values at initialization (e.g., resolve regex patterns to indices)
+  - Maintain state across calls
+  - Perform expensive setup once rather than every call
+
+  .. code-block:: python
+
+      class posture:
+        def __init__(self, cfg: RewardTermCfg, env: ManagerBasedRlEnv):
+          # Resolve std dict to tensor once at init
+          self.std = resolve_std_to_tensor(cfg.params["std"], env)
+
+        def __call__(self, env, **kwargs) -> torch.Tensor:
+          # Use cached self.std
+          return compute_posture_reward(env, self.std)
+
+      RewardTermCfg(func=posture, params={"std": {".*knee.*": 0.3}}, weight=1.0)
+
+  Class-based terms can optionally implement ``reset(env_ids)`` for per-episode state.
+  """
+
+  func: Any
+  """The callable that computes this term's value. Can be a function or a class.
+  Classes are auto-instantiated with ``(cfg=term_cfg, env=env)``."""
+
+  params: dict[str, Any] = field(default_factory=lambda: {})
+  """Additional keyword arguments passed to func when called."""
+
+
+class ManagerTermBase:
+  def __init__(self, env: ManagerBasedRlEnv):
+    self._env = env
+
+  # Properties.
+
+  @property
+  def num_envs(self) -> int:
+    return self._env.num_envs
+
+  @property
+  def device(self) -> str:
+    return self._env.device
+
+  @property
+  def name(self) -> str:
+    return self.__class__.__name__
+
+  # Methods.
+
+  def reset(self, env_ids: torch.Tensor | slice | None) -> Any:
+    """Resets the manager term."""
+    del env_ids  # Unused.
+    pass
+
+  def __call__(self, *args, **kwargs) -> Any:
+    """Returns the value of the term required by the manager."""
+    raise NotImplementedError
+
+
+class ManagerBase(abc.ABC):
+  """Base class for all managers."""
+
+  def __init__(self, env: ManagerBasedRlEnv):
+    self._env = env
+
+    self._prepare_terms()
+
+  # Properties.
+
+  @property
+  def num_envs(self) -> int:
+    return self._env.num_envs
+
+  @property
+  def device(self) -> str:
+    return self._env.device
+
+  @property
+  @abc.abstractmethod
+  def active_terms(self) -> list[str] | dict[Any, list[str]]:
+    raise NotImplementedError
+
+  # Methods.
+
+  def reset(self, env_ids: torch.Tensor) -> dict[str, Any]:
+    """Resets the manager and returns logging info for the current step."""
+    del env_ids  # Unused.
+    return {}
+
+  def _check_term_shape(self, term_name: str, value: torch.Tensor) -> None:
+    if value.shape != (self.num_envs,):
+      manager_name = type(self).__name__
+      raise ValueError(
+        f"{manager_name} term '{term_name}' returned shape {tuple(value.shape)}, "
+        f"expected ({self.num_envs},)."
+      )
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    raise NotImplementedError
+
+  @abc.abstractmethod
+  def _prepare_terms(self):
+    raise NotImplementedError
+
+  def _resolve_common_term_cfg(self, term_name: str, term_cfg: ManagerTermBaseCfg):
+    del term_name  # Unused.
+    for value in term_cfg.params.values():
+      if isinstance(value, SceneEntityCfg):
+        value.resolve(self._env.scene)
+    if inspect.isclass(term_cfg.func):
+      term_cfg.func = term_cfg.func(cfg=term_cfg, env=self._env)
diff --git a/src/mjlab/managers/metrics_manager.py b/src/mjlab/managers/metrics_manager.py
new file mode 100644
index 0000000..020f8ab
--- /dev/null
+++ b/src/mjlab/managers/metrics_manager.py
@@ -0,0 +1,249 @@
+"""Metrics manager for logging custom per-step metrics during training."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal, Sequence
+
+import torch
+from prettytable import PrettyTable
+
+from mjlab.managers.manager_base import ManagerBase, ManagerTermBaseCfg
+
+if TYPE_CHECKING:
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+
+REDUCE_OPTIONS = ("last", "max", "mean", "sum")
+
+
+@dataclass(kw_only=True)
+class MetricsTermCfg(ManagerTermBaseCfg):
+  """Configuration for a metrics term.
+
+  Attributes:
+    per_substep: If True, evaluate this term once per physics substep inside
+      the decimation loop and report the per-step mean. Only the integrated
+      state (qpos, qvel, act) is current mid-loop; all derived quantities
+      (xpos, xquat, site_xpos, actuator_force, contacts, ...) are stale.
+
+    reduce: How to aggregate per-step values into an episode metric.
+      - ``"mean"`` (default) reports ``sum / step_count``.
+      - ``"last"`` reports the value from the final step of the episode,
+        useful for binary success metrics that should not be averaged over
+        timesteps.
+      - ``"max"`` reports the highest value seen during the episode, useful
+        for peak metrics like maximum power or contact force.
+      - ``"sum"`` reports the accumulated total over the episode, useful for
+        cumulative quantities like episodic reward or total distance
+        traveled.
+  """
+
+  per_substep: bool = False
+  reduce: Literal["last", "max", "mean", "sum"] = "mean"
+
+
+class MetricsManager(ManagerBase):
+  """Accumulates per-step metric values, reports episode averages.
+
+  Unlike rewards, metrics have no weight, no dt scaling, and no
+  normalization by episode length. Episode values are true per-step
+  averages (sum / step_count), so a metric in [0,1] stays in [0,1]
+  in the logger.
+  """
+
+  _env: ManagerBasedRlEnv
+
+  def __init__(self, cfg: dict[str, MetricsTermCfg], env: ManagerBasedRlEnv):
+    self._term_names: list[str] = list()
+    self._term_cfgs: list[MetricsTermCfg] = list()
+    self._class_term_cfgs: list[MetricsTermCfg] = list()
+    self._step_term_indices: list[int] = list()
+    self._substep_term_indices: list[int] = list()
+
+    self.cfg = deepcopy(cfg)
+    super().__init__(env=env)
+
+    self._episode_sums: dict[str, torch.Tensor] = {}
+    self._episode_max: dict[str, torch.Tensor] = {}
+    for idx, term_name in enumerate(self._term_names):
+      if self._term_cfgs[idx].reduce not in REDUCE_OPTIONS:
+        msg = (
+          f"The reduce method '{self._term_cfgs[idx].reduce}' for metric '{term_name}' "
+          f"is unknown. Valid options are {REDUCE_OPTIONS}."
+        )
+        raise ValueError(msg)
+
+      self._episode_sums[term_name] = torch.zeros(
+        self.num_envs, dtype=torch.float, device=self.device
+      )
+
+      if self._term_cfgs[idx].reduce == "max":
+        self._episode_max[term_name] = torch.full(
+          (self.num_envs,), float("-inf"), dtype=torch.float, device=self.device
+        )
+    # Pre-resolved tensor refs for substep terms to avoid dict lookups in
+    # the hot loop.
+    self._substep_accum: list[torch.Tensor] = []
+    self._substep_episode_sums: list[torch.Tensor] = []
+    self._substep_episode_max: list[torch.Tensor | None] = []
+    for idx in self._substep_term_indices:
+      name = self._term_names[idx]
+      buf = torch.zeros(self.num_envs, dtype=torch.float, device=self.device)
+      self._substep_accum.append(buf)
+      self._substep_episode_sums.append(self._episode_sums[name])
+      self._substep_episode_max.append(self._episode_max.get(name))
+    self._substep_count: int = 0
+    self._step_count = torch.zeros(self.num_envs, dtype=torch.long, device=self.device)
+    self._step_values = torch.zeros(
+      (self.num_envs, len(self._term_names)), dtype=torch.float, device=self.device
+    )
+
+  def __str__(self) -> str:
+    msg = f"<MetricsManager> contains {len(self._term_names)} active terms.\n"
+    table = PrettyTable()
+    table.title = "Active Metrics Terms"
+    table.field_names = ["Index", "Name"]
+    table.align["Name"] = "l"
+    for index, name in enumerate(self._term_names):
+      table.add_row([index, name])
+    msg += table.get_string()
+    msg += "\n"
+    return msg
+
+  # Properties.
+
+  @property
+  def active_terms(self) -> list[str]:
+    return self._term_names
+
+  # Methods.
+
+  def reset(
+    self, env_ids: torch.Tensor | slice | None = None
+  ) -> dict[str, torch.Tensor]:
+    if env_ids is None:
+      env_ids = slice(None)
+    extras = {}
+    counts = self._step_count[env_ids].float()
+    # Avoid division by zero for envs that haven't stepped.
+    safe_counts = torch.clamp(counts, min=1.0)
+    for idx, key in enumerate(self._episode_sums):
+      reduce = self._term_cfgs[idx].reduce
+      if reduce == "max":
+        extras["Episode_Metrics/" + key] = torch.mean(self._episode_max[key][env_ids])
+        self._episode_max[key][env_ids] = float("-inf")
+
+      elif reduce == "last":
+        extras["Episode_Metrics/" + key] = torch.mean(self._step_values[env_ids, idx])
+
+      elif reduce == "sum":
+        extras["Episode_Metrics/" + key] = torch.mean(self._episode_sums[key][env_ids])
+
+      else:
+        extras["Episode_Metrics/" + key] = torch.mean(
+          self._episode_sums[key][env_ids] / safe_counts
+        )
+
+      self._episode_sums[key][env_ids] = 0.0
+    self._step_count[env_ids] = 0
+
+    for buf in self._substep_accum:
+      buf[env_ids] = 0.0
+
+    for term_cfg in self._class_term_cfgs:
+      term_cfg.func.reset(env_ids=env_ids)
+
+    return extras
+
+  def compute_substep(self) -> None:
+    """Accumulate per-substep metric values inside the decimation loop.
+
+    No-op when no ``per_substep`` terms are configured.
+    """
+    if not self._substep_term_indices:
+      return
+    for i, idx in enumerate(self._substep_term_indices):
+      value = self._compute_term(idx)
+      self._substep_accum[i] += value
+    self._substep_count += 1
+
+  def compute(self) -> None:
+    self._step_count += 1
+    if self._substep_term_indices and self._substep_count > 0:
+      for i, idx in enumerate(self._substep_term_indices):
+        avg = self._substep_accum[i] / self._substep_count
+        self._substep_episode_sums[i] += avg
+        self._step_values[:, idx] = avg
+        max_buf = self._substep_episode_max[i]
+        if max_buf is not None:
+          torch.maximum(max_buf, avg, out=max_buf)
+        self._substep_accum[i].zero_()
+      self._substep_count = 0
+    for idx in self._step_term_indices:
+      name = self._term_names[idx]
+      value = self._compute_term(idx)
+      self._episode_sums[name] += value
+      self._step_values[:, idx] = value
+      if name in self._episode_max:
+        torch.maximum(self._episode_max[name], value, out=self._episode_max[name])
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    terms = []
+    for idx, name in enumerate(self._term_names):
+      terms.append((name, [self._step_values[env_idx, idx].cpu().item()]))
+    return terms
+
+  def _prepare_terms(self):
+    for term_name, term_cfg in self.cfg.items():
+      term_cfg: MetricsTermCfg | None
+      if term_cfg is None:
+        print(f"term: {term_name} set to None, skipping...")
+        continue
+      self._resolve_common_term_cfg(term_name, term_cfg)
+      idx = len(self._term_names)
+      self._term_names.append(term_name)
+      self._term_cfgs.append(term_cfg)
+      if term_cfg.per_substep:
+        self._substep_term_indices.append(idx)
+      else:
+        self._step_term_indices.append(idx)
+      if hasattr(term_cfg.func, "reset") and callable(term_cfg.func.reset):
+        self._class_term_cfgs.append(term_cfg)
+
+  def _compute_term(self, idx: int) -> torch.Tensor:
+    name = self._term_names[idx]
+    term_cfg = self._term_cfgs[idx]
+    value = term_cfg.func(self._env, **term_cfg.params)
+    self._check_term_shape(name, value)
+    return value
+
+
+class NullMetricsManager:
+  """Placeholder for absent metrics manager that safely no-ops all operations."""
+
+  def __init__(self):
+    self.active_terms: list[str] = []
+    self.cfg = None
+
+  def __str__(self) -> str:
+    return "<NullMetricsManager> (inactive)"
+
+  def __repr__(self) -> str:
+    return "NullMetricsManager()"
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    return []
+
+  def reset(self, env_ids: torch.Tensor | None = None) -> dict[str, float]:
+    return {}
+
+  def compute_substep(self) -> None:
+    pass
+
+  def compute(self) -> None:
+    pass
diff --git a/src/mjlab/managers/observation_manager.py b/src/mjlab/managers/observation_manager.py
new file mode 100644
index 0000000..10fac80
--- /dev/null
+++ b/src/mjlab/managers/observation_manager.py
@@ -0,0 +1,515 @@
+"""Observation manager for computing observations."""
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Literal, Sequence
+
+import numpy as np
+import torch
+from prettytable import PrettyTable
+
+from mjlab.managers.manager_base import ManagerBase, ManagerTermBaseCfg
+from mjlab.utils.buffers import CircularBuffer, DelayBuffer
+from mjlab.utils.noise import noise_cfg, noise_model
+from mjlab.utils.noise.noise_cfg import NoiseCfg, NoiseModelCfg
+
+
+@dataclass
+class ObservationTermCfg(ManagerTermBaseCfg):
+  """Configuration for an observation term.
+
+  Processing pipeline: compute → noise → clip → scale → delay → history.
+  Delay models sensor latency. History provides temporal context. Both are optional
+  and can be combined.
+  """
+
+  noise: NoiseCfg | NoiseModelCfg | None = None
+  """Noise model to apply to the observation."""
+
+  clip: tuple[float, float] | None = None
+  """Range (min, max) to clip the observation values."""
+
+  scale: tuple[float, ...] | float | torch.Tensor | None = None
+  """Scaling factor(s) to multiply the observation by."""
+
+  delay_min_lag: int = 0
+  """Minimum lag (in steps) for delayed observations. Lag sampled uniformly from
+  [min_lag, max_lag]. Convert to ms: lag * (1000 / control_hz)."""
+
+  delay_max_lag: int = 0
+  """Maximum lag (in steps) for delayed observations. Use min=max for constant delay."""
+
+  delay_per_env: bool = True
+  """If True, each environment samples its own lag. If False, all environments share
+  the same lag at each step."""
+
+  delay_hold_prob: float = 0.0
+  """Probability of reusing the previous lag instead of resampling. Useful for
+  temporally correlated latency patterns."""
+
+  delay_update_period: int = 0
+  """Resample lag every N steps (models multi-rate sensors). If 0, update every step."""
+
+  delay_per_env_phase: bool = True
+  """If True and update_period > 0, stagger update timing across envs to avoid
+  synchronized resampling."""
+
+  history_length: int = 0
+  """Number of past observations to keep in history. 0 = no history."""
+
+  flatten_history_dim: bool = True
+  """Whether to flatten the history dimension into observation.
+
+  When True and concatenate_terms=True, uses term-major ordering:
+  [A_t0, A_t1, ..., A_tH-1, B_t0, B_t1, ..., B_tH-1, ...]
+  See docs/source/observation.rst for details on ordering."""
+
+
+@dataclass
+class ObservationGroupCfg:
+  """Configuration for an observation group.
+
+  An observation group bundles multiple observation terms together. Groups are
+  typically used to separate observations for different purposes (e.g., "actor"
+  for the actor, "critic" for the value function).
+  """
+
+  terms: dict[str, ObservationTermCfg]
+  """Dictionary mapping term names to their configurations."""
+
+  concatenate_terms: bool = True
+  """Whether to concatenate all terms into a single tensor. If False, returns
+  a dict mapping term names to their individual tensors."""
+
+  concatenate_dim: int = -1
+  """Dimension along which to concatenate terms. Default -1 (last dimension)."""
+
+  enable_corruption: bool = False
+  """Whether to apply noise corruption to observations. Set to True during
+  training for domain randomization, False during evaluation."""
+
+  history_length: int | None = None
+  """Group-level history length override. If set, applies to all terms in
+  this group. If None, each term uses its own ``history_length`` setting."""
+
+  flatten_history_dim: bool = True
+  """Whether to flatten history into the observation dimension. If True,
+  observations have shape ``(num_envs, obs_dim * history_length)``. If False,
+  shape is ``(num_envs, history_length, obs_dim)``."""
+
+  nan_policy: Literal["disabled", "warn", "sanitize", "error"] = "disabled"
+  """NaN/Inf handling policy for observations in this group.
+
+  - 'disabled': No checks (default, fastest)
+  - 'warn': Log warning with term name and env IDs, then sanitize (debugging)
+  - 'sanitize': Silent sanitization to 0.0 like reward manager (safe for production)
+  - 'error': Raise ValueError on NaN/Inf (strict development mode)
+  """
+
+  nan_check_per_term: bool = True
+  """If True, check each observation term individually to identify NaN source.
+  If False, check only the final concatenated output (faster but less informative).
+  Only applies when nan_policy != 'disabled'."""
+
+
+class ObservationManager(ManagerBase):
+  """Manages observation computation for the environment.
+
+  The observation manager computes observations from multiple terms organized
+  into groups. Each term can have noise, clipping, scaling, delay, and history
+  applied. Groups can optionally concatenate their terms into a single tensor.
+  """
+
+  def __init__(self, cfg: dict[str, ObservationGroupCfg], env):
+    self.cfg = deepcopy(cfg)
+    super().__init__(env=env)
+
+    self._group_obs_dim: dict[str, tuple[int, ...] | list[tuple[int, ...]]] = dict()
+
+    for group_name, group_term_dims in self._group_obs_term_dim.items():
+      if self._group_obs_concatenate[group_name]:
+        term_dims = torch.stack(
+          [torch.tensor(dims, device="cpu") for dims in group_term_dims], dim=0
+        )
+        if len(term_dims.shape) > 1:
+          if self._group_obs_concatenate_dim[group_name] >= 0:
+            dim = self._group_obs_concatenate_dim[group_name] - 1
+          else:
+            dim = self._group_obs_concatenate_dim[group_name]
+          dim_sum = torch.sum(term_dims[:, dim], dim=0)
+          term_dims[0, dim] = dim_sum
+          term_dims = term_dims[0]
+        else:
+          term_dims = torch.sum(term_dims, dim=0)
+        self._group_obs_dim[group_name] = tuple(term_dims.tolist())
+      else:
+        self._group_obs_dim[group_name] = group_term_dims
+
+    self._obs_buffer: dict[str, torch.Tensor | dict[str, torch.Tensor]] | None = None
+
+  def __str__(self) -> str:
+    msg = f"<ObservationManager> contains {len(self._group_obs_term_names)} groups.\n"
+    for group_name, group_dim in self._group_obs_dim.items():
+      table = PrettyTable()
+      table.title = f"Active Observation Terms in Group: '{group_name}'"
+      if self._group_obs_concatenate[group_name]:
+        table.title += f" (shape: {group_dim})"  # type: ignore
+      table.field_names = ["Index", "Name", "Shape"]
+      table.align["Name"] = "l"
+      obs_terms = zip(
+        self._group_obs_term_names[group_name],
+        self._group_obs_term_dim[group_name],
+        self._group_obs_term_cfgs[group_name],
+        strict=False,
+      )
+      for index, (name, dims, term_cfg) in enumerate(obs_terms):
+        if term_cfg.history_length > 0 and term_cfg.flatten_history_dim:
+          # Flattened history: show (9,) ← 3×(3,)
+          original_size = int(np.prod(dims)) // term_cfg.history_length
+          original_shape = (original_size,) if len(dims) == 1 else dims[1:]
+          shape_str = f"{dims}  ← {term_cfg.history_length}×{original_shape}"
+        else:
+          shape_str = str(tuple(dims))
+        table.add_row([index, name, shape_str])
+      msg += table.get_string()
+      msg += "\n"
+    return msg
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    terms = []
+
+    if self._obs_buffer is None:
+      self.compute()
+    assert self._obs_buffer is not None
+    obs_buffer: dict[str, torch.Tensor | dict[str, torch.Tensor]] = self._obs_buffer
+
+    for group_name, _ in self.group_obs_dim.items():
+      if not self.group_obs_concatenate[group_name]:
+        buffers = obs_buffer[group_name]
+        assert isinstance(buffers, dict)
+        for name, term in buffers.items():
+          terms.append((group_name + "-" + name, term[env_idx].cpu().tolist()))  # type: ignore[unsupported-operator]
+        continue
+
+      idx = 0
+      data = obs_buffer[group_name]
+      assert isinstance(data, torch.Tensor)
+      for name, shape in zip(
+        self._group_obs_term_names[group_name],
+        self._group_obs_term_dim[group_name],
+        strict=False,
+      ):
+        data_length = np.prod(shape)
+        term = data[env_idx, idx : idx + data_length]
+        terms.append((group_name + "-" + name, term.cpu().tolist()))
+        idx += data_length
+
+    return terms
+
+  # Properties.
+
+  @property
+  def active_terms(self) -> dict[str, list[str]]:
+    return self._group_obs_term_names
+
+  @property
+  def group_obs_dim(self) -> dict[str, tuple[int, ...] | list[tuple[int, ...]]]:
+    return self._group_obs_dim
+
+  @property
+  def group_obs_term_dim(self) -> dict[str, list[tuple[int, ...]]]:
+    return self._group_obs_term_dim
+
+  @property
+  def group_obs_concatenate(self) -> dict[str, bool]:
+    return self._group_obs_concatenate
+
+  # Methods.
+
+  def get_term_cfg(self, group_name: str, term_name: str) -> ObservationTermCfg:
+    if group_name not in self._group_obs_term_names:
+      raise ValueError(f"Group '{group_name}' not found in active groups.")
+    if term_name not in self._group_obs_term_names[group_name]:
+      raise ValueError(f"Term '{term_name}' not found in group '{group_name}'.")
+    index = self._group_obs_term_names[group_name].index(term_name)
+    return self._group_obs_term_cfgs[group_name][index]
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> dict[str, float]:
+    # Invalidate cache since reset envs will have different observations.
+    self._obs_buffer = None
+
+    for group_name, group_cfg in self._group_obs_class_term_cfgs.items():
+      for term_cfg in group_cfg:
+        term_cfg.func.reset(env_ids=env_ids)
+      for term_name in self._group_obs_term_names[group_name]:
+        batch_ids = None if isinstance(env_ids, slice) else env_ids
+        if term_name in self._group_obs_term_delay_buffer[group_name]:
+          self._group_obs_term_delay_buffer[group_name][term_name].reset(
+            batch_ids=batch_ids
+          )
+        if term_name in self._group_obs_term_history_buffer[group_name]:
+          self._group_obs_term_history_buffer[group_name][term_name].reset(
+            batch_ids=batch_ids
+          )
+    for group_mods in self._group_obs_class_instances.values():
+      for mod in group_mods.values():
+        mod.reset(env_ids=env_ids)
+    return {}
+
+  def _check_and_handle_nans(
+    self, tensor: torch.Tensor, context: str, policy: str
+  ) -> torch.Tensor:
+    """Check for NaN/Inf and handle according to policy.
+
+    Args:
+      tensor: Observation tensor to check.
+      context: Context string for error/warning messages (e.g., "actor/base_lin_vel").
+      policy: NaN handling policy ("disabled", "warn", "sanitize", "error").
+
+    Returns:
+      The tensor, potentially sanitized depending on policy.
+
+    Raises:
+      ValueError: If policy is "error" and NaN/Inf detected.
+    """
+    if policy == "disabled":
+      return tensor
+
+    has_nan = torch.isnan(tensor).any()
+    has_inf = torch.isinf(tensor).any()
+
+    if not (has_nan or has_inf):
+      return tensor
+
+    if policy == "error":
+      nan_mask = torch.isnan(tensor).any(dim=-1) | torch.isinf(tensor).any(dim=-1)
+      nan_env_ids = torch.where(nan_mask)[0].cpu().tolist()
+      raise ValueError(
+        f"NaN/Inf detected in observation '{context}' "
+        f"for environments: {nan_env_ids[:10]}"
+      )
+
+    if policy == "warn":
+      nan_mask = torch.isnan(tensor).any(dim=-1) | torch.isinf(tensor).any(dim=-1)
+      nan_env_ids = torch.where(nan_mask)[0].cpu().tolist()
+      print(
+        f"[ObservationManager] NaN/Inf in '{context}' "
+        f"(envs: {nan_env_ids[:5]}). Sanitizing to 0."
+      )
+
+    # Sanitize (applies to both "warn" and "sanitize" policies).
+    return torch.nan_to_num(tensor, nan=0.0, posinf=0.0, neginf=0.0)
+
+  def compute(
+    self,
+    update_history: bool = False,
+    env_ids: torch.Tensor | None = None,
+  ) -> dict[str, torch.Tensor | dict[str, torch.Tensor]]:
+    """Compute observations for all groups.
+
+    With env_ids=None (the per-step path), history and delay buffers advance
+    for all envs. With env_ids (the reset path), only the reset envs' buffers
+    receive their post-reset frame (a backfill); other envs' buffers, delay
+    schedules, and lag draws are untouched, so a partial reset does not
+    advance their observation timelines.
+    """
+    assert env_ids is None or update_history, (
+      "env_ids is only meaningful with update_history=True (the reset path)."
+    )
+    # Return cached observations if not updating and cache exists.
+    # This prevents double-pushing to delay buffers when compute() is called
+    # multiple times per control step (e.g., in get_observations() after step()).
+    if not update_history and self._obs_buffer is not None:
+      return self._obs_buffer
+
+    obs_buffer: dict[str, torch.Tensor | dict[str, torch.Tensor]] = dict()
+    for group_name in self._group_obs_term_names:
+      obs_buffer[group_name] = self.compute_group(group_name, update_history, env_ids)
+    self._obs_buffer = obs_buffer
+    return obs_buffer
+
+  def compute_group(
+    self,
+    group_name: str,
+    update_history: bool = False,
+    env_ids: torch.Tensor | None = None,
+  ) -> torch.Tensor | dict[str, torch.Tensor]:
+    group_cfg = self.cfg[group_name]
+    group_term_names = self._group_obs_term_names[group_name]
+    group_obs: dict[str, torch.Tensor] = {}
+    obs_terms = zip(
+      group_term_names, self._group_obs_term_cfgs[group_name], strict=False
+    )
+    for term_name, term_cfg in obs_terms:
+      obs: torch.Tensor = term_cfg.func(self._env, **term_cfg.params).clone()
+      if isinstance(term_cfg.noise, noise_cfg.NoiseCfg):
+        obs = term_cfg.noise.apply(obs)
+      elif isinstance(term_cfg.noise, noise_cfg.NoiseModelCfg):
+        obs = self._group_obs_class_instances[group_name][term_name](obs)
+      if term_cfg.clip:
+        obs = obs.clip_(min=term_cfg.clip[0], max=term_cfg.clip[1])
+      if term_cfg.scale is not None:
+        scale = term_cfg.scale
+        assert isinstance(scale, torch.Tensor)
+        obs = obs.mul_(scale)
+
+      # Check for NaN/Inf before delay/history buffers (per-term checking).
+      if group_cfg.nan_check_per_term and group_cfg.nan_policy != "disabled":
+        obs = self._check_and_handle_nans(
+          obs, context=f"{group_name}/{term_name}", policy=group_cfg.nan_policy
+        )
+
+      if term_cfg.delay_max_lag > 0:
+        delay_buffer = self._group_obs_term_delay_buffer[group_name][term_name]
+        if env_ids is None or not delay_buffer.is_initialized:
+          delay_buffer.append(obs)
+          obs = delay_buffer.compute()
+        else:
+          delay_buffer.backfill(obs, env_ids)
+          obs = delay_buffer.peek()
+      if term_cfg.history_length > 0:
+        circular_buffer = self._group_obs_term_history_buffer[group_name][term_name]
+        if env_ids is None or not circular_buffer.is_initialized:
+          if update_history or not circular_buffer.is_initialized:
+            circular_buffer.append(obs)
+        else:
+          circular_buffer.backfill(obs, env_ids)
+
+        if term_cfg.flatten_history_dim:
+          group_obs[term_name] = circular_buffer.buffer.reshape(self._env.num_envs, -1)
+        else:
+          group_obs[term_name] = circular_buffer.buffer
+      else:
+        group_obs[term_name] = obs
+
+    # Final NaN check for non-per-term checking.
+    if not group_cfg.nan_check_per_term and group_cfg.nan_policy != "disabled":
+      if self._group_obs_concatenate[group_name]:
+        # Will check after concatenation below.
+        pass
+      else:
+        for term_name in group_obs:
+          group_obs[term_name] = self._check_and_handle_nans(
+            group_obs[term_name],
+            context=f"{group_name}/{term_name}",
+            policy=group_cfg.nan_policy,
+          )
+
+    if self._group_obs_concatenate[group_name]:
+      result = torch.cat(
+        list(group_obs.values()), dim=self._group_obs_concatenate_dim[group_name]
+      )
+      # Final check for concatenated result (non-per-term checking).
+      if not group_cfg.nan_check_per_term and group_cfg.nan_policy != "disabled":
+        result = self._check_and_handle_nans(
+          result, context=group_name, policy=group_cfg.nan_policy
+        )
+      return result
+    return group_obs
+
+  def _prepare_terms(self) -> None:
+    self._group_obs_term_names: dict[str, list[str]] = dict()
+    self._group_obs_term_dim: dict[str, list[tuple[int, ...]]] = dict()
+    self._group_obs_term_cfgs: dict[str, list[ObservationTermCfg]] = dict()
+    self._group_obs_class_term_cfgs: dict[str, list[ObservationTermCfg]] = dict()
+    self._group_obs_concatenate: dict[str, bool] = dict()
+    self._group_obs_concatenate_dim: dict[str, int] = dict()
+    self._group_obs_class_instances: dict[str, dict[str, noise_model.NoiseModel]] = {}
+    self._group_obs_term_delay_buffer: dict[str, dict[str, DelayBuffer]] = dict()
+    self._group_obs_term_history_buffer: dict[str, dict[str, CircularBuffer]] = dict()
+
+    for group_name, group_cfg in self.cfg.items():
+      group_cfg: ObservationGroupCfg | None
+      if group_cfg is None:
+        print(f"group: {group_name} set to None, skipping...")
+        continue
+
+      if not any(t is not None for t in group_cfg.terms.values()):
+        print(f"group: {group_name} has no active terms, skipping...")
+        continue
+
+      self._group_obs_term_names[group_name] = list()
+      self._group_obs_term_dim[group_name] = list()
+      self._group_obs_term_cfgs[group_name] = list()
+      self._group_obs_class_term_cfgs[group_name] = list()
+      self._group_obs_class_instances[group_name] = {}
+      group_entry_delay_buffer: dict[str, DelayBuffer] = dict()
+      group_entry_history_buffer: dict[str, CircularBuffer] = dict()
+
+      self._group_obs_concatenate[group_name] = group_cfg.concatenate_terms
+      self._group_obs_concatenate_dim[group_name] = (
+        group_cfg.concatenate_dim + 1
+        if group_cfg.concatenate_dim >= 0
+        else group_cfg.concatenate_dim
+      )
+
+      for term_name, term_cfg in group_cfg.terms.items():
+        term_cfg: ObservationTermCfg | None
+        if term_cfg is None:
+          print(f"term: {term_name} set to None, skipping...")
+          continue
+
+        # NOTE: This deepcopy is important to avoid cross-group contamination of term
+        # configs.
+        term_cfg = deepcopy(term_cfg)
+        self._resolve_common_term_cfg(term_name, term_cfg)
+
+        if not group_cfg.enable_corruption:
+          term_cfg.noise = None
+        if group_cfg.history_length is not None:
+          term_cfg.history_length = group_cfg.history_length
+          term_cfg.flatten_history_dim = group_cfg.flatten_history_dim
+        self._group_obs_term_names[group_name].append(term_name)
+        self._group_obs_term_cfgs[group_name].append(term_cfg)
+        if hasattr(term_cfg.func, "reset") and callable(term_cfg.func.reset):
+          self._group_obs_class_term_cfgs[group_name].append(term_cfg)
+
+        obs_dims = tuple(term_cfg.func(self._env, **term_cfg.params).shape)
+
+        if term_cfg.scale is not None:
+          term_cfg.scale = torch.as_tensor(
+            term_cfg.scale, dtype=torch.float, device=self._env.device
+          ).clone()
+
+        if term_cfg.noise is not None and isinstance(
+          term_cfg.noise, noise_cfg.NoiseModelCfg
+        ):
+          noise_model_cls = term_cfg.noise.class_type
+          assert issubclass(noise_model_cls, noise_model.NoiseModel), (
+            f"Class type for observation term '{term_name}' NoiseModelCfg"
+            f" is not a subclass of 'NoiseModel'. Received: '{type(noise_model_cls)}'."
+          )
+          self._group_obs_class_instances[group_name][term_name] = noise_model_cls(
+            term_cfg.noise, num_envs=self._env.num_envs, device=self._env.device
+          )
+
+        if term_cfg.delay_max_lag > 0:
+          group_entry_delay_buffer[term_name] = DelayBuffer(
+            min_lag=term_cfg.delay_min_lag,
+            max_lag=term_cfg.delay_max_lag,
+            batch_size=self._env.num_envs,
+            device=self._env.device,
+            per_env=term_cfg.delay_per_env,
+            hold_prob=term_cfg.delay_hold_prob,
+            update_period=term_cfg.delay_update_period,
+            per_env_phase=term_cfg.delay_per_env_phase,
+          )
+
+        if term_cfg.history_length > 0:
+          group_entry_history_buffer[term_name] = CircularBuffer(
+            max_len=term_cfg.history_length,
+            batch_size=self._env.num_envs,
+            device=self._env.device,
+          )
+          old_dims = list(obs_dims)
+          old_dims.insert(1, term_cfg.history_length)
+          obs_dims = tuple(old_dims)
+          if term_cfg.flatten_history_dim:
+            obs_dims = (obs_dims[0], int(np.prod(obs_dims[1:])))
+
+        self._group_obs_term_dim[group_name].append(obs_dims[1:])
+
+      self._group_obs_term_delay_buffer[group_name] = group_entry_delay_buffer
+      self._group_obs_term_history_buffer[group_name] = group_entry_history_buffer
diff --git a/src/mjlab/managers/recorder_manager.py b/src/mjlab/managers/recorder_manager.py
new file mode 100644
index 0000000..cf1f011
--- /dev/null
+++ b/src/mjlab/managers/recorder_manager.py
@@ -0,0 +1,265 @@
+"""Recorder manager for logging environment data during rollouts."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import torch
+from prettytable import PrettyTable
+
+from mjlab.managers.manager_base import ManagerBase, ManagerTermBase, ManagerTermBaseCfg
+
+if TYPE_CHECKING:
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+
+
+@dataclass
+class RecorderTermCfg(ManagerTermBaseCfg):
+  """Configuration for a recorder term.
+
+  ``func`` must be a :class:`RecorderTerm` subclass. Function-based terms are not
+  supported because recorder terms are stateful (file handles, buffers, etc.).
+  """
+
+
+class RecorderTerm(ManagerTermBase):
+  """Base class for recorder terms.
+
+  Override only the lifecycle methods you need. Each method is a no-op by default so
+  subclasses are not required to implement all of them.
+
+  The environment is available as ``self._env``, giving access to ``self._env.obs_buf``,
+  ``self._env.action_manager.action``, and all other environment state.
+
+  Example::
+
+    class CsvRecorder(RecorderTerm):
+      def __init__(self, cfg, env):
+        super().__init__(cfg, env)
+        self._file = open(cfg.params["path"], "w", newline="")
+        self._writer = csv.writer(self._file)
+
+      def record_pre_reset(self, env_ids):
+        # Terminal transition: action is still intact here.
+        # It will be zeroed by _reset_idx immediately after this returns.
+        obs = self._env.obs_buf["actor"][env_ids].cpu().numpy()
+        act = self._env.action_manager.action[env_ids].cpu().numpy()
+        for o, a in zip(obs, act):
+          self._writer.writerow(o.tolist() + a.tolist())
+
+      def record_post_step(self):
+        # Skip envs that just reset: their terminal pair was written in record_pre_reset
+        # and their action is now zeroed.
+        mask = ~self._env.reset_buf
+        obs = self._env.obs_buf["actor"][mask].cpu().numpy()
+        act = self._env.action_manager.action[mask].cpu().numpy()
+        for o, a in zip(obs, act):
+          self._writer.writerow(o.tolist() + a.tolist())
+
+      def close(self):
+        self._file.close()
+  """
+
+  def __init__(self, cfg: RecorderTermCfg, env: ManagerBasedRlEnv):
+    super().__init__(env)  # ManagerTermBase only accepts env
+    self.cfg = cfg
+
+  def record_pre_reset(self, env_ids: torch.Tensor) -> None:
+    """Called in ``env.step()`` before terminated environments are reset.
+
+    **What is available:**
+
+    - ``obs_buf`` contains the observation from the *end of the previous step* (the
+      input the agent used to choose the terminal action). It does **not** contain the
+      post-action terminal observation (the state reached after applying the action),
+      which is never computed for resetting environments.
+    - ``action_manager.action`` contains the action applied during this step. This is
+      the correct terminal action. It will be zeroed for these environments by
+      ``_reset_idx`` immediately after this hook returns, so capture it here if you
+      need it later.
+    - ``reward_buf`` contains the reward for this terminal step.
+    - ``reset_terminated`` and ``reset_time_outs`` reflect why each environment is
+      resetting.
+
+    This is the right hook to record the terminal transition
+    ``(obs_t, action_t, reward_t, done=True)`` for each resetting environment.
+
+    Args:
+      env_ids: Indices of environments that are about to be reset.
+    """
+    del env_ids  # Unused in base implementation.
+
+  def record_post_reset(self, env_ids: torch.Tensor) -> None:
+    """Called after a reset completes with fresh observations computed.
+
+    Fires at the end of ``env.reset()`` (covering all environments on the initial call)
+    and within ``env.step()`` for each batch of environments that terminates, after
+    state has been overwritten and new observations computed.
+
+    At this point ``obs_buf[env_ids]`` holds the initial observation of the new episode
+    and ``action_manager.action[env_ids]`` is zero (no action has been taken in the new
+    episode yet).
+
+    Use this hook to initialize per-episode state or record the first observation of a
+    new episode.
+
+    Args:
+      env_ids: Indices of environments that were reset.
+    """
+    del env_ids  # Unused in base implementation.
+
+  def record_post_step(self) -> None:
+    """Called at the end of every ``env.step()`` with fresh observations.
+
+    At this point ``obs_buf`` holds the new observation for every environment and
+    ``action_manager.action`` holds the action that was applied during this step.
+    **Exception:** for environments that reset during this step,
+    ``action_manager.action`` has been zeroed by ``_reset_idx`` and ``obs_buf`` holds
+    the initial observation of the new episode rather than the post-action terminal
+    observation. Use ``record_pre_reset`` to capture the terminal ``(obs, action)``
+    pair for those environments. Resetting environments are identified by
+    ``self._env.reset_buf``.
+    """
+
+  def close(self) -> None:
+    """Called when the environment closes.
+
+    Release file handles, flush write buffers, or finalize output here.
+    """
+
+  def __call__(self):
+    raise NotImplementedError(
+      "RecorderTerm is not invoked via __call__. "
+      "Override the lifecycle methods instead."
+    )
+
+
+class RecorderManager(ManagerBase):
+  """Orchestrates recorder terms during environment rollouts.
+
+  Holds a collection of :class:`RecorderTerm` instances and calls their lifecycle
+  methods at the appropriate points in the environment loop. The manager has no opinion
+  on how data is stored; each term handles its own I/O entirely.
+
+  Register terms by adding them to the ``recorders`` dict on
+  :class:`~mjlab.envs.ManagerBasedRlEnvCfg`. If the dict is empty, the environment
+  substitutes a :class:`NullRecorderManager` with zero overhead.
+  """
+
+  def __init__(self, cfg: dict[str, RecorderTermCfg], env: ManagerBasedRlEnv):
+    self._terms: dict[str, RecorderTerm] = {}
+    self.cfg = deepcopy(cfg)
+    super().__init__(env)  # calls _prepare_terms()
+
+  def __str__(self) -> str:
+    msg = f"<RecorderManager> contains {len(self._terms)} active terms.\n"
+    table = PrettyTable()
+    table.title = "Active Recorder Terms"
+    table.field_names = ["Index", "Name"]
+    for idx, name in enumerate(self._terms):
+      table.add_row([idx, name])
+    return msg + table.get_string()
+
+  def __contains__(self, name: str) -> bool:
+    """Return True if a term named ``name`` is registered."""
+    return name in self._terms
+
+  @property
+  def active_terms(self) -> list[str]:
+    """List of active term names."""
+    return list(self._terms.keys())
+
+  def get_term(self, name: str) -> RecorderTerm:
+    """Return the recorder term registered under ``name``.
+
+    Use this to reach a recorder's public methods (e.g. to start/stop logging)
+    from outside the env loop without touching private state.
+
+    Args:
+      name: Term name as registered in ``ManagerBasedRlEnvCfg.recorders``.
+
+    Raises:
+      KeyError: If no term is registered under ``name``.
+    """
+    try:
+      return self._terms[name]
+    except KeyError:
+      msg = f"No recorder term named '{name}'. Active terms: {self.active_terms}"
+      raise KeyError(msg) from None
+
+  def record_pre_reset(self, env_ids: torch.Tensor) -> None:
+    """Forward to each term's :meth:`RecorderTerm.record_pre_reset`."""
+    for term in self._terms.values():
+      term.record_pre_reset(env_ids)
+
+  def record_post_reset(self, env_ids: torch.Tensor) -> None:
+    """Forward to each term's :meth:`RecorderTerm.record_post_reset`."""
+    for term in self._terms.values():
+      term.record_post_reset(env_ids)
+
+  def record_post_step(self) -> None:
+    """Forward to each term's :meth:`RecorderTerm.record_post_step`."""
+    for term in self._terms.values():
+      term.record_post_step()
+
+  def close(self) -> None:
+    """Forward to each term's :meth:`RecorderTerm.close`."""
+    for term in self._terms.values():
+      term.close()
+
+  def _prepare_terms(self):
+    for name, cfg in self.cfg.items():
+      if cfg is None:
+        continue
+      self._resolve_common_term_cfg(name, cfg)
+      # _resolve_common_term_cfg instantiates class-based terms in-place.
+      if not isinstance(cfg.func, RecorderTerm):
+        raise TypeError(
+          f"Recorder term '{name}': func must be a RecorderTerm subclass,"
+          f" got {type(cfg.func).__name__}. Function-based terms are not"
+          " supported."
+        )
+      self._terms[name] = cfg.func
+
+
+class NullRecorderManager:
+  """No-op fallback used when no recorder terms are configured.
+
+  All methods are no-ops. This class is not a :class:`ManagerBase` subclass
+  so it carries zero overhead.
+  """
+
+  def __init__(self):
+    self.active_terms: list[str] = []
+    self.cfg = None
+
+  def __str__(self) -> str:
+    return "<NullRecorderManager> (inactive)"
+
+  def __repr__(self) -> str:
+    return "NullRecorderManager()"
+
+  def __contains__(self, name: str) -> bool:
+    """Always returns False since there are no terms."""
+    del name
+    return False
+
+  def get_term(self, name: str) -> RecorderTerm:
+    """Always raises KeyError since there are no terms."""
+    del name
+    msg = "NullRecorderManager has no terms."
+    raise KeyError(msg)
+
+  def record_pre_reset(self, env_ids: torch.Tensor) -> None:
+    del env_ids
+
+  def record_post_reset(self, env_ids: torch.Tensor) -> None:
+    del env_ids
+
+  def record_post_step(self) -> None:
+    pass
+
+  def close(self) -> None:
+    pass
diff --git a/src/mjlab/managers/reward_manager.py b/src/mjlab/managers/reward_manager.py
new file mode 100644
index 0000000..8a66a13
--- /dev/null
+++ b/src/mjlab/managers/reward_manager.py
@@ -0,0 +1,175 @@
+"""Reward manager for computing reward signals."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+import torch
+from prettytable import PrettyTable
+
+from mjlab.managers.manager_base import ManagerBase, ManagerTermBaseCfg
+
+if TYPE_CHECKING:
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+  from mjlab.viewer.debug_visualizer import DebugVisualizer
+
+
+@dataclass(kw_only=True)
+class RewardTermCfg(ManagerTermBaseCfg):
+  """Configuration for a reward term."""
+
+  func: Any
+  """The callable that computes this reward term's value."""
+
+  weight: float
+  """Weight multiplier for this reward term."""
+
+
+class RewardManager(ManagerBase):
+  """Manages reward computation by aggregating weighted reward terms.
+
+  Reward Scaling Behavior:
+    By default, rewards are scaled by the environment step duration (dt). This
+    normalizes cumulative episodic rewards across different simulation frequencies.
+    The scaling can be disabled via the ``scale_by_dt`` parameter.
+
+    When ``scale_by_dt=True`` (default):
+      - ``reward_buf`` (returned by ``compute()``) = raw_value * weight * dt
+      - ``_episode_sums`` (cumulative rewards) are scaled by dt
+      - ``Episode_Reward/*`` logged metrics are scaled by dt
+
+    When ``scale_by_dt=False``:
+      - ``reward_buf`` = raw_value * weight (no dt scaling)
+
+    Regardless of the scaling setting:
+      - ``_step_reward`` (via ``get_active_iterable_terms()``) always contains
+        the unscaled reward rate (raw_value * weight)
+  """
+
+  _env: ManagerBasedRlEnv
+
+  def __init__(
+    self,
+    cfg: dict[str, RewardTermCfg],
+    env: ManagerBasedRlEnv,
+    *,
+    scale_by_dt: bool = True,
+  ):
+    self._term_names: list[str] = list()
+    self._term_cfgs: list[RewardTermCfg] = list()
+    self._class_term_cfgs: list[RewardTermCfg] = list()
+    self._scale_by_dt = scale_by_dt
+
+    self.cfg = deepcopy(cfg)
+    super().__init__(env=env)
+    self._episode_sums = dict()
+    for term_name in self._term_names:
+      self._episode_sums[term_name] = torch.zeros(
+        self.num_envs, dtype=torch.float, device=self.device
+      )
+    self._reward_buf = torch.zeros(self.num_envs, dtype=torch.float, device=self.device)
+    self._step_reward = torch.zeros(
+      (self.num_envs, len(self._term_names)), dtype=torch.float, device=self.device
+    )
+
+  def __str__(self) -> str:
+    msg = f"<RewardManager> contains {len(self._term_names)} active terms.\n"
+    table = PrettyTable()
+    table.title = "Active Reward Terms"
+    table.field_names = ["Index", "Name", "Weight"]
+    table.align["Name"] = "l"
+    table.align["Weight"] = "r"
+    for index, (name, term_cfg) in enumerate(
+      zip(self._term_names, self._term_cfgs, strict=False)
+    ):
+      table.add_row([index, name, term_cfg.weight])
+    msg += table.get_string()
+    msg += "\n"
+    return msg
+
+  # Properties.
+
+  @property
+  def active_terms(self) -> list[str]:
+    return self._term_names
+
+  # Methods.
+
+  def reset(
+    self, env_ids: torch.Tensor | slice | None = None
+  ) -> dict[str, torch.Tensor]:
+    if env_ids is None:
+      env_ids = slice(None)
+    extras = {}
+    for key in self._episode_sums.keys():
+      episodic_sum_avg = torch.mean(self._episode_sums[key][env_ids])
+      extras["Episode_Reward/" + key] = (
+        episodic_sum_avg / self._env.max_episode_length_s
+      )
+      self._episode_sums[key][env_ids] = 0.0
+    for term_cfg in self._class_term_cfgs:
+      term_cfg.func.reset(env_ids=env_ids)
+    return extras
+
+  def compute(self, dt: float) -> torch.Tensor:
+    self._reward_buf[:] = 0.0
+    scale = dt if self._scale_by_dt else 1.0
+    for term_idx, (name, term_cfg) in enumerate(
+      zip(self._term_names, self._term_cfgs, strict=False)
+    ):
+      if term_cfg.weight == 0.0:
+        self._step_reward[:, term_idx] = 0.0
+        continue
+      value = term_cfg.func(self._env, **term_cfg.params)
+      self._check_term_shape(name, value)
+      value = value * term_cfg.weight * scale
+      # NaN/Inf can occur from corrupted physics state; zero them to avoid policy crash.
+      value = torch.nan_to_num(value, nan=0.0, posinf=0.0, neginf=0.0)
+      self._reward_buf += value
+      self._episode_sums[name] += value
+      self._step_reward[:, term_idx] = value / scale
+    return self._reward_buf
+
+  def debug_vis(self, visualizer: DebugVisualizer) -> None:
+    """Delegate debug visualization to class-based reward terms."""
+    for _, func in self.get_visualizable_terms():
+      func.debug_vis(visualizer)
+
+  def get_visualizable_terms(self) -> list[tuple[str, Any]]:
+    """Return ``(name, func)`` pairs for class-based terms with debug_vis."""
+    results: list[tuple[str, Any]] = []
+    for term_cfg in self._class_term_cfgs:
+      if not hasattr(term_cfg.func, "debug_vis"):
+        continue
+      name = next(
+        n
+        for n, c in zip(self._term_names, self._term_cfgs, strict=False)
+        if c is term_cfg
+      )
+      results.append((name, term_cfg.func))
+    return results
+
+  def get_active_iterable_terms(self, env_idx):
+    terms = []
+    for idx, name in enumerate(self._term_names):
+      terms.append((name, [self._step_reward[env_idx, idx].cpu().item()]))
+    return terms
+
+  def get_term_cfg(self, term_name: str) -> RewardTermCfg:
+    if term_name not in self._term_names:
+      raise ValueError(f"Term '{term_name}' not found in active terms.")
+    return self._term_cfgs[self._term_names.index(term_name)]
+
+  def _prepare_terms(self):
+    for term_name, term_cfg in self.cfg.items():
+      term_cfg: RewardTermCfg | None
+      if term_cfg is None:
+        print(f"term: {term_name} set to None, skipping...")
+        continue
+      self._resolve_common_term_cfg(term_name, term_cfg)
+      self._term_names.append(term_name)
+      self._term_cfgs.append(term_cfg)
+      if hasattr(term_cfg.func, "reset") and callable(term_cfg.func.reset):
+        self._class_term_cfgs.append(term_cfg)
diff --git a/src/mjlab/managers/scene_entity_config.py b/src/mjlab/managers/scene_entity_config.py
new file mode 100644
index 0000000..65e470b
--- /dev/null
+++ b/src/mjlab/managers/scene_entity_config.py
@@ -0,0 +1,265 @@
+"""Configuration for scene entities used by manager terms."""
+
+from dataclasses import dataclass, field
+from typing import NamedTuple
+
+from mjlab.entity import Entity
+from mjlab.scene import Scene
+
+
+class _FieldConfig(NamedTuple):
+  """Configuration for a resolvable entity field."""
+
+  names_attr: str
+  ids_attr: str
+  find_method: str
+  num_attr: str
+  kind_label: str
+
+
+_FIELD_CONFIGS = [
+  _FieldConfig("joint_names", "joint_ids", "find_joints", "num_joints", "joint"),
+  _FieldConfig("body_names", "body_ids", "find_bodies", "num_bodies", "body"),
+  _FieldConfig("geom_names", "geom_ids", "find_geoms", "num_geoms", "geom"),
+  _FieldConfig("site_names", "site_ids", "find_sites", "num_sites", "site"),
+  _FieldConfig(
+    "actuator_names", "actuator_ids", "find_actuators", "num_actuators", "actuator"
+  ),
+  _FieldConfig("tendon_names", "tendon_ids", "find_tendons", "num_tendons", "tendon"),
+  _FieldConfig(
+    "camera_names",
+    "camera_ids",
+    "find_cameras",
+    "num_cameras",
+    "camera",
+  ),
+  _FieldConfig(
+    "light_names",
+    "light_ids",
+    "find_lights",
+    "num_lights",
+    "light",
+  ),
+  _FieldConfig(
+    "material_names",
+    "material_ids",
+    "find_materials",
+    "num_materials",
+    "material",
+  ),
+  _FieldConfig(
+    "texture_names",
+    "texture_ids",
+    "find_textures",
+    "num_textures",
+    "texture",
+  ),
+  _FieldConfig("pair_names", "pair_ids", "find_pairs", "num_pairs", "pair"),
+]
+
+
+@dataclass
+class SceneEntityCfg:
+  """Configuration for a scene entity that is used by the manager's term.
+
+  This configuration allows flexible specification of entity components either by name
+  or by ID. During resolution, it ensures consistency between names and IDs, and can
+  optimize to slice(None) when all components are selected.
+  """
+
+  name: str
+  """The name of the entity in the scene."""
+
+  joint_names: str | tuple[str, ...] | None = None
+  """Names of joints to include. Can be a single string or tuple."""
+
+  joint_ids: list[int] | slice = field(default_factory=lambda: slice(None))
+  """IDs of joints to include. Can be a list or slice."""
+
+  body_names: str | tuple[str, ...] | None = None
+  """Names of bodies to include. Can be a single string or tuple."""
+
+  body_ids: list[int] | slice = field(default_factory=lambda: slice(None))
+  """IDs of bodies to include. Can be a list or slice."""
+
+  geom_names: str | tuple[str, ...] | None = None
+  """Names of geometries to include. Can be a single string or tuple."""
+
+  geom_ids: list[int] | slice = field(default_factory=lambda: slice(None))
+  """IDs of geometries to include. Can be a list or slice."""
+
+  site_names: str | tuple[str, ...] | None = None
+  """Names of sites to include. Can be a single string or tuple."""
+
+  site_ids: list[int] | slice = field(default_factory=lambda: slice(None))
+  """IDs of sites to include. Can be a list or slice."""
+
+  actuator_names: str | list[str] | None = None
+  """Names of actuators to include. Can be a single string or list."""
+
+  actuator_ids: list[int] | slice = field(default_factory=lambda: slice(None))
+  """IDs of actuators to include. Can be a list or slice."""
+
+  tendon_names: str | tuple[str, ...] | None = None
+  """Names of tendons to include. Can be a single string or tuple."""
+
+  tendon_ids: list[int] | slice = field(default_factory=lambda: slice(None))
+  """IDs of tendons to include. Can be a list or slice."""
+
+  camera_names: str | tuple[str, ...] | None = None
+  """Names of cameras to include. Can be a single string or tuple."""
+
+  camera_ids: list[int] | slice = field(default_factory=lambda: slice(None))
+  """IDs of cameras to include. Can be a list or slice."""
+
+  light_names: str | tuple[str, ...] | None = None
+  """Names of lights to include. Can be a single string or tuple."""
+
+  light_ids: list[int] | slice = field(default_factory=lambda: slice(None))
+  """IDs of lights to include. Can be a list or slice."""
+
+  material_names: str | tuple[str, ...] | None = None
+  """Names of materials to include. Can be a single string or tuple."""
+
+  material_ids: list[int] | slice = field(default_factory=lambda: slice(None))
+  """IDs of materials to include. Can be a list or slice."""
+
+  texture_names: str | tuple[str, ...] | None = None
+  """Names of textures to include. Can be a single string or tuple."""
+
+  texture_ids: list[int] | slice = field(default_factory=lambda: slice(None))
+  """IDs of textures to include. Can be a list or slice."""
+
+  pair_names: str | tuple[str, ...] | None = None
+  """Names of contact pairs to include. Can be a single string or tuple."""
+
+  pair_ids: list[int] | slice = field(default_factory=lambda: slice(None))
+  """IDs of contact pairs to include. Can be a list or slice."""
+
+  preserve_order: bool = False
+  """If True, maintains the order of components as specified."""
+
+  def resolve(self, scene: Scene) -> None:
+    """Resolve names and IDs for all configured fields.
+
+    This method ensures consistency between names and IDs for each field type.
+    It handles three cases:
+    1. Both names and IDs provided: Validates they match
+    2. Only names provided: Computes IDs (optimizes to slice(None) if all selected)
+    3. Only IDs provided: Computes names
+
+    Args:
+      scene: The scene containing the entity to resolve against.
+
+    Raises:
+      ValueError: If provided names and IDs are inconsistent.
+      KeyError: If the entity name is not found in the scene.
+    """
+    entity = scene[self.name]
+
+    for config in _FIELD_CONFIGS:
+      self._resolve_field(entity, config)
+
+  def _resolve_field(self, entity: Entity, config: _FieldConfig) -> None:
+    """Resolve a single field's names and IDs.
+
+    Args:
+      entity: The entity to resolve against.
+      config: Field configuration specifying attribute names and methods.
+    """
+    names = getattr(self, config.names_attr)
+    ids = getattr(self, config.ids_attr)
+
+    # Early return if nothing to resolve.
+    if names is None and not isinstance(ids, list):
+      return
+
+    # Get entity metadata.
+    entity_all_names = getattr(entity, config.names_attr)
+    entity_count = getattr(entity, config.num_attr)
+    find_method = getattr(entity, config.find_method)
+
+    # Normalize single values to lists for uniform processing.
+    names = self._normalize_to_list(names)
+    if isinstance(ids, (int, list)):
+      ids = self._normalize_to_list(ids)
+      setattr(self, config.ids_attr, ids)
+
+    # Handle three resolution cases.
+    if names is not None and isinstance(ids, list):
+      setattr(self, config.names_attr, names)
+      self._validate_consistency(
+        names, ids, entity_all_names, find_method, config.kind_label
+      )
+    elif names is not None:
+      self._resolve_names_to_ids(
+        names,
+        entity_all_names,
+        entity_count,
+        find_method,
+        config.names_attr,
+        config.ids_attr,
+      )
+    elif isinstance(ids, list):
+      self._resolve_ids_to_names(ids, entity_all_names, config.names_attr)
+
+  def _normalize_to_list(self, value: str | int | tuple | list | None) -> list | None:
+    """Convert single values to lists for uniform processing."""
+    if value is None:
+      return None
+    if isinstance(value, (str, int)):
+      return [value]
+    if isinstance(value, list):
+      return value
+    return list(value)
+
+  def _validate_consistency(
+    self,
+    names: list[str],
+    ids: list[int],
+    entity_all_names: list[str],
+    find_method,
+    kind_label: str,
+  ) -> None:
+    """Validate that provided names and IDs are consistent.
+
+    Raises:
+      ValueError: If names and IDs don't match.
+    """
+    found_ids, _ = find_method(names, preserve_order=self.preserve_order)
+    computed_names = [entity_all_names[i] for i in ids]
+
+    if found_ids != ids or computed_names != names:
+      raise ValueError(
+        f"Inconsistent {kind_label} names and indices. "
+        f"Names {names} resolved to indices {found_ids}, "
+        f"but indices {ids} (mapping to names {computed_names}) were provided."
+      )
+
+  def _resolve_names_to_ids(
+    self,
+    names: list[str],
+    entity_all_names: list[str],
+    entity_count: int,
+    find_method,
+    names_attr: str,
+    ids_attr: str,
+  ) -> None:
+    """Resolve names to IDs, optimizing to slice(None) when all are selected."""
+    found_ids, found_names = find_method(names, preserve_order=self.preserve_order)
+
+    # Keep names and IDs in the same order.
+    setattr(self, names_attr, found_names)
+
+    # Optimize to slice(None) if all components are selected in order.
+    if len(found_ids) == entity_count and found_names == list(entity_all_names):
+      setattr(self, ids_attr, slice(None))
+    else:
+      setattr(self, ids_attr, found_ids)
+
+  def _resolve_ids_to_names(
+    self, ids: list[int], entity_all_names: list[str], names_attr: str
+  ) -> None:
+    """Resolve IDs to their corresponding names."""
+    resolved_names = [entity_all_names[i] for i in ids]
+    setattr(self, names_attr, resolved_names)
diff --git a/src/mjlab/managers/termination_manager.py b/src/mjlab/managers/termination_manager.py
new file mode 100644
index 0000000..d62ef35
--- /dev/null
+++ b/src/mjlab/managers/termination_manager.py
@@ -0,0 +1,141 @@
+"""Termination manager for computing done signals."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Sequence
+
+import torch
+from prettytable import PrettyTable
+
+from mjlab.managers.manager_base import ManagerBase, ManagerTermBaseCfg
+
+if TYPE_CHECKING:
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+
+
+@dataclass
+class TerminationTermCfg(ManagerTermBaseCfg):
+  """Configuration for a termination term."""
+
+  time_out: bool = False
+  """Whether the term contributes towards episodic timeouts."""
+
+
+class TerminationManager(ManagerBase):
+  """Manages termination conditions for the environment.
+
+  The termination manager aggregates multiple termination terms to compute
+  episode done signals. Terms can be either truncations (time-based) or
+  terminations (failure conditions).
+  """
+
+  _env: ManagerBasedRlEnv
+
+  def __init__(self, cfg: dict[str, TerminationTermCfg], env: ManagerBasedRlEnv):
+    self._term_names: list[str] = list()
+    self._term_cfgs: list[TerminationTermCfg] = list()
+    self._class_term_cfgs: list[TerminationTermCfg] = list()
+
+    self.cfg = deepcopy(cfg)
+    super().__init__(env)
+
+    self._term_dones = dict()
+    for term_name in self._term_names:
+      self._term_dones[term_name] = torch.zeros(
+        self.num_envs, device=self.device, dtype=torch.bool
+      )
+    self._truncated_buf = torch.zeros(
+      self.num_envs, device=self.device, dtype=torch.bool
+    )
+    self._terminated_buf = torch.zeros_like(self._truncated_buf)
+
+  def __str__(self) -> str:
+    msg = f"<TerminationManager> contains {len(self._term_names)} active terms.\n"
+    table = PrettyTable()
+    table.title = "Active Termination Terms"
+    table.field_names = ["Index", "Name", "Time Out"]
+    table.align["Name"] = "l"
+    for index, (name, term_cfg) in enumerate(
+      zip(self._term_names, self._term_cfgs, strict=False)
+    ):
+      table.add_row([index, name, term_cfg.time_out])
+    msg += table.get_string()
+    msg += "\n"
+    return msg
+
+  # Properties.
+
+  @property
+  def active_terms(self) -> list[str]:
+    return self._term_names
+
+  @property
+  def dones(self) -> torch.Tensor:
+    return self._truncated_buf | self._terminated_buf
+
+  @property
+  def time_outs(self) -> torch.Tensor:
+    return self._truncated_buf
+
+  @property
+  def terminated(self) -> torch.Tensor:
+    return self._terminated_buf
+
+  # Methods.
+
+  def reset(
+    self, env_ids: torch.Tensor | slice | None = None
+  ) -> dict[str, torch.Tensor]:
+    if env_ids is None:
+      env_ids = slice(None)
+    extras = {}
+    for key in self._term_dones.keys():
+      extras["Episode_Termination/" + key] = torch.count_nonzero(
+        self._term_dones[key][env_ids]
+      ).item()
+    for term_cfg in self._class_term_cfgs:
+      term_cfg.func.reset(env_ids=env_ids)
+    return extras
+
+  def compute(self) -> torch.Tensor:
+    self._truncated_buf[:] = False
+    self._terminated_buf[:] = False
+    for name, term_cfg in zip(self._term_names, self._term_cfgs, strict=False):
+      value = term_cfg.func(self._env, **term_cfg.params)
+      self._check_term_shape(name, value)
+      if term_cfg.time_out:
+        self._truncated_buf |= value
+      else:
+        self._terminated_buf |= value
+      self._term_dones[name][:] = value
+    return self._truncated_buf | self._terminated_buf
+
+  def get_term(self, name: str) -> torch.Tensor:
+    return self._term_dones[name]
+
+  def get_term_cfg(self, term_name: str) -> TerminationTermCfg:
+    if term_name not in self._term_names:
+      raise ValueError(f"Term '{term_name}' not found in active terms.")
+    return self._term_cfgs[self._term_names.index(term_name)]
+
+  def get_active_iterable_terms(
+    self, env_idx: int
+  ) -> Sequence[tuple[str, Sequence[float]]]:
+    terms = []
+    for key in self._term_dones.keys():
+      terms.append((key, [self._term_dones[key][env_idx].float().cpu().item()]))
+    return terms
+
+  def _prepare_terms(self):
+    for term_name, term_cfg in self.cfg.items():
+      term_cfg: TerminationTermCfg | None
+      if term_cfg is None:
+        print(f"term: {term_name} set to None, skipping...")
+        continue
+      self._resolve_common_term_cfg(term_name, term_cfg)
+      self._term_names.append(term_name)
+      self._term_cfgs.append(term_cfg)
+      if hasattr(term_cfg.func, "reset") and callable(term_cfg.func.reset):
+        self._class_term_cfgs.append(term_cfg)
diff --git a/src/mjlab/py.typed b/src/mjlab/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/src/mjlab/rl/__init__.py b/src/mjlab/rl/__init__.py
new file mode 100644
index 0000000..e3d0de1
--- /dev/null
+++ b/src/mjlab/rl/__init__.py
@@ -0,0 +1,6 @@
+from mjlab.rl.config import RslRlBaseRunnerCfg as RslRlBaseRunnerCfg
+from mjlab.rl.config import RslRlModelCfg as RslRlModelCfg
+from mjlab.rl.config import RslRlOnPolicyRunnerCfg as RslRlOnPolicyRunnerCfg
+from mjlab.rl.config import RslRlPpoAlgorithmCfg as RslRlPpoAlgorithmCfg
+from mjlab.rl.runner import MjlabOnPolicyRunner as MjlabOnPolicyRunner
+from mjlab.rl.vecenv_wrapper import RslRlVecEnvWrapper as RslRlVecEnvWrapper
diff --git a/src/mjlab/rl/config.py b/src/mjlab/rl/config.py
new file mode 100644
index 0000000..8ce233d
--- /dev/null
+++ b/src/mjlab/rl/config.py
@@ -0,0 +1,145 @@
+"""RSL-RL configuration."""
+
+from dataclasses import dataclass, field
+from typing import Any, Literal, Tuple
+
+
+@dataclass
+class RslRlModelCfg:
+  """Config for a single neural network model (Actor or Critic)."""
+
+  hidden_dims: Tuple[int, ...] = (128, 128, 128)
+  """The hidden dimensions of the network."""
+  activation: str = "elu"
+  """The activation function."""
+  obs_normalization: bool = False
+  """Whether to normalize the observations. Default is False."""
+  cnn_cfg: dict[str, Any] | None = None
+  """CNN encoder config. When set, class_name should be "CNNModel".
+
+  Passed to ``rsl_rl.modules.CNN``. Common keys: output_channels,
+  kernel_size, stride, padding, activation, global_pool, max_pool.
+  """
+  distribution_cfg: dict[str, Any] | None = None
+  """Distribution config dict passed to rsl_rl. Example::
+
+    {"class_name": "GaussianDistribution",
+     "init_std": 1.0, "std_type": "scalar"}
+
+  ``None`` means deterministic output (use for critic).
+  """
+  rnn_type: str | None = None
+  """RNN type ("lstm" or "gru"). When set, class_name should be "RNNModel"."""
+  rnn_hidden_dim: int = 256
+  """Hidden state dimension for the RNN."""
+  rnn_num_layers: int = 1
+  """Number of stacked RNN layers."""
+  class_name: str = "MLPModel"
+  """Model class name resolved by RSL-RL (MLPModel, CNNModel, or RNNModel)."""
+
+
+@dataclass
+class RslRlPpoAlgorithmCfg:
+  """Config for the PPO algorithm."""
+
+  num_learning_epochs: int = 5
+  """The number of learning epochs per update."""
+  num_mini_batches: int = 4
+  """The number of mini-batches per update.
+  mini batch size = num_envs * num_steps / num_mini_batches
+  """
+  learning_rate: float = 1e-3
+  """The learning rate."""
+  schedule: Literal["adaptive", "fixed"] = "adaptive"
+  """The learning rate schedule."""
+  gamma: float = 0.99
+  """The discount factor."""
+  lam: float = 0.95
+  """The lambda parameter for Generalized Advantage Estimation (GAE)."""
+  entropy_coef: float = 0.005
+  """The coefficient for the entropy loss."""
+  desired_kl: float = 0.01
+  """The desired KL divergence between the new and old policies."""
+  max_grad_norm: float = 1.0
+  """The maximum gradient norm for the policy."""
+  value_loss_coef: float = 1.0
+  """The coefficient for the value loss."""
+  use_clipped_value_loss: bool = True
+  """Whether to use clipped value loss."""
+  clip_param: float = 0.2
+  """The clipping parameter for the policy."""
+  normalize_advantage_per_mini_batch: bool = False
+  """Whether to normalize the advantage per mini-batch. Default is False. If True, the
+  advantage is normalized over the mini-batches only. Otherwise, the advantage is
+  normalized over the entire collected trajectories.
+  """
+  optimizer: Literal["adam", "adamw", "sgd", "rmsprop"] = "adam"
+  """The optimizer to use."""
+  share_cnn_encoders: bool = False
+  """Share CNN encoders between actor and critic."""
+  class_name: str = "PPO"
+  """Algorithm class name resolved by RSL-RL."""
+
+
+@dataclass
+class RslRlBaseRunnerCfg:
+  seed: int = 42
+  """The seed for the experiment. Default is 42."""
+  num_steps_per_env: int = 24
+  """The number of steps per environment update."""
+  max_iterations: int = 300
+  """The maximum number of iterations."""
+  obs_groups: dict[str, tuple[str, ...]] = field(
+    default_factory=lambda: {"actor": ("actor",), "critic": ("critic",)},
+  )
+  save_interval: int = 50
+  """The number of iterations between saves."""
+  experiment_name: str = "exp1"
+  """Directory name used to group runs under ``{log_root}/{experiment_name}/``.
+  The log root defaults to ``logs/rsl_rl`` and can be overridden with
+  ``--log-root`` on the CLI."""
+  run_name: str = ""
+  """Optional label appended to the timestamped run directory
+  (e.g. ``2025-01-27_14-30-00_{run_name}``). Also becomes the
+  display name for the run in wandb."""
+  logger: Literal["wandb", "tensorboard"] = "wandb"
+  """The logger to use. Default is wandb."""
+  wandb_project: str = "mjlab"
+  """The wandb project name."""
+  wandb_tags: Tuple[str, ...] = ()
+  """Tags for the wandb run. Default is empty tuple."""
+  resume: bool = False
+  """Whether to resume the experiment. Default is False."""
+  load_run: str = ".*"
+  """The run directory to load. Default is ".*" which means all runs. If regex
+  expression, the latest (alphabetical order) matching run will be loaded.
+  """
+  load_checkpoint: str = "model_.*.pt"
+  """The checkpoint file to load. Default is "model_.*.pt" (all). If regex expression,
+  the latest (alphabetical order) matching file will be loaded.
+  """
+  clip_actions: float | None = None
+  """The clipping range for action values. If None (default), no clipping is applied."""
+  upload_model: bool = True
+  """Whether to upload model files (.pt, .onnx) to W&B on save. Set to
+  False to keep metric logging but avoid storage usage. Default is True."""
+
+
+@dataclass
+class RslRlOnPolicyRunnerCfg(RslRlBaseRunnerCfg):
+  class_name: str = "OnPolicyRunner"
+  """The runner class name. Default is OnPolicyRunner."""
+  actor: RslRlModelCfg = field(
+    default_factory=lambda: RslRlModelCfg(
+      distribution_cfg={
+        "class_name": "GaussianDistribution",
+        "init_std": 1.0,
+        "std_type": "scalar",
+      }
+    )
+  )
+  """The actor configuration."""
+  critic: RslRlModelCfg = field(default_factory=RslRlModelCfg)
+  """The critic configuration."""
+  algorithm: RslRlPpoAlgorithmCfg = field(default_factory=RslRlPpoAlgorithmCfg)
+  """The algorithm configuration."""
diff --git a/src/mjlab/rl/exporter_utils.py b/src/mjlab/rl/exporter_utils.py
new file mode 100644
index 0000000..7ee4aad
--- /dev/null
+++ b/src/mjlab/rl/exporter_utils.py
@@ -0,0 +1,125 @@
+"""Shared utilities for ONNX policy export across RL tasks."""
+
+import onnx
+import torch
+
+from mjlab.entity import Entity
+from mjlab.envs import ManagerBasedRlEnv
+from mjlab.envs.mdp.actions import JointPositionAction
+
+
+def list_to_csv_str(
+  arr, *, decimals: int = 3, delimiter: str = ",", sub_delimiter: str = ";"
+) -> str:
+  """Convert list to CSV string with specified decimal precision.
+
+  Elements that are themselves sequences (e.g. a per-dimension scale or a
+  [min, max] clip range) are joined with `sub_delimiter` instead of being
+  `str()`-formatted, which would otherwise embed a second, ambiguous set of
+  commas inside the top-level comma-delimited string.
+  """
+  fmt = f"{{:.{decimals}f}}"
+
+  def format_scalar(x) -> str:
+    return fmt.format(x) if isinstance(x, (int, float)) else str(x)
+
+  def format_entry(x) -> str:
+    if isinstance(x, (list, tuple)):
+      return sub_delimiter.join(format_scalar(v) for v in x)
+    return format_scalar(x)
+
+  return delimiter.join(format_entry(x) for x in arr)
+
+
+def get_base_metadata(
+  env: ManagerBasedRlEnv, run_path: str
+) -> dict[str, list | str | float]:
+  """Get base metadata common to all RL policy exports.
+
+  Args:
+    env: The RL environment.
+    run_path: W&B run path or other identifier.
+
+  Returns:
+    Dictionary of metadata fields that are common across all tasks.
+  """
+  robot: Entity = env.scene["robot"]
+  joint_action = env.action_manager.get_term("joint_pos")
+  assert isinstance(joint_action, JointPositionAction)
+  # Build mapping from joint name to actuator ID for natural joint order.
+  # Each spec actuator controls exactly one joint (via its target field).
+  joint_name_to_ctrl_id = {}
+  for actuator in robot.spec.actuators:
+    joint_name = actuator.target.split("/")[-1]
+    joint_name_to_ctrl_id[joint_name] = actuator.id
+  # Get actuator IDs in natural joint order (same order as robot.joint_names).
+  ctrl_ids_natural = [
+    joint_name_to_ctrl_id[jname]
+    for jname in robot.joint_names  # global joint order
+    if jname in joint_name_to_ctrl_id  # skip non-actuated joints
+  ]
+  joint_stiffness = env.sim.mj_model.actuator_gainprm[ctrl_ids_natural, 0]
+  joint_damping = -env.sim.mj_model.actuator_biasprm[ctrl_ids_natural, 2]
+  observation_term_scale: list = []
+  observation_term_flatten_history_dim: list = []
+  observation_term_history_length: list = []
+  observation_term_clip: list = []
+  observation_names = env.observation_manager.active_terms["actor"]
+
+  for active_term in observation_names:
+    cfg = env.observation_manager.get_term_cfg("actor", active_term)
+
+    if cfg.scale is None:
+      observation_term_scale.append(1.0)
+    else:
+      raw_scale = cfg.scale
+      scale = (
+        raw_scale.cpu().tolist() if isinstance(raw_scale, torch.Tensor) else raw_scale
+      )
+      observation_term_scale.append(scale)
+
+    raw_clip = cfg.clip
+    if raw_clip is None:
+      observation_term_clip.append([float("-inf"), float("inf")])
+    else:
+      observation_term_clip.append(list(raw_clip))
+
+    observation_term_flatten_history_dim.append(cfg.flatten_history_dim)
+    observation_term_history_length.append(cfg.history_length)
+
+  return {
+    "run_path": run_path,
+    "joint_names": list(robot.joint_names),
+    "joint_stiffness": joint_stiffness.tolist(),
+    "joint_damping": joint_damping.tolist(),
+    "default_joint_pos": robot.data.default_joint_pos[0].cpu().tolist(),
+    "command_names": list(env.command_manager.active_terms),
+    "observation_names": observation_names,
+    "observation_terms_scale": observation_term_scale,
+    "observation_terms_flatten_history_dim": observation_term_flatten_history_dim,
+    "observation_terms_history_length": observation_term_history_length,
+    "observation_terms_clip": observation_term_clip,
+    "action_scale": joint_action._scale[0].cpu().tolist()
+    if isinstance(joint_action._scale, torch.Tensor)
+    else joint_action._scale,
+  }
+
+
+def attach_metadata_to_onnx(
+  onnx_path: str, metadata: dict[str, list | str | float]
+) -> None:
+  """Attach metadata to an ONNX model file.
+
+  Args:
+    onnx_path: Path to the ONNX model file.
+    metadata: Dictionary of metadata key-value pairs to attach.
+  """
+  model = onnx.load(onnx_path)
+
+  for k, v in metadata.items():
+    entry = onnx.StringStringEntryProto()
+    entry.key = k
+    entry.value = list_to_csv_str(v) if isinstance(v, list) else str(v)
+    model.metadata_props.append(entry)
+
+  onnx.save(model, onnx_path)
diff --git a/src/mjlab/rl/runner.py b/src/mjlab/rl/runner.py
new file mode 100644
index 0000000..2934929
--- /dev/null
+++ b/src/mjlab/rl/runner.py
@@ -0,0 +1,141 @@
+import os
+from pathlib import Path
+
+import torch
+from rsl_rl.env import VecEnv
+from rsl_rl.runners import OnPolicyRunner
+
+from mjlab.rl.vecenv_wrapper import RslRlVecEnvWrapper
+
+
+class MjlabOnPolicyRunner(OnPolicyRunner):
+  """Base runner that persists environment state across checkpoints."""
+
+  env: RslRlVecEnvWrapper
+
+  def __init__(
+    self,
+    env: VecEnv,
+    train_cfg: dict,
+    log_dir: str | None = None,
+    device: str = "cpu",
+  ) -> None:
+    # Strip None-valued optional configs so MLPModel doesn't receive them.
+    for key in ("actor", "critic"):
+      if key in train_cfg:
+        for opt in ("cnn_cfg", "distribution_cfg"):
+          if train_cfg[key].get(opt) is None:
+            train_cfg[key].pop(opt, None)
+        if train_cfg[key].get("rnn_type") is None:
+          for opt in ("rnn_type", "rnn_hidden_dim", "rnn_num_layers"):
+            train_cfg[key].pop(opt, None)
+    super().__init__(env, train_cfg, log_dir, device)
+
+  def export_policy_to_onnx(
+    self, path: str, filename: str = "policy.onnx", verbose: bool = False
+  ) -> None:
+    """Export policy to ONNX format using legacy export path.
+
+    Overrides the base implementation to set dynamo=False, avoiding warnings about
+    dynamic_axes being deprecated with the new TorchDynamo export path
+    (torch>=2.9 default).
+    """
+    onnx_model = self.alg.get_policy().as_onnx(verbose=verbose)
+    onnx_model.to("cpu")
+    onnx_model.eval()
+    os.makedirs(path, exist_ok=True)
+    torch.onnx.export(
+      onnx_model,
+      onnx_model.get_dummy_inputs(),  # type: ignore[operator]
+      os.path.join(path, filename),
+      export_params=True,
+      opset_version=18,
+      verbose=verbose,
+      input_names=onnx_model.input_names,  # type: ignore[arg-type]
+      output_names=onnx_model.output_names,  # type: ignore[arg-type]
+      dynamic_axes={},
+      dynamo=False,
+    )
+
+  @staticmethod
+  def _get_export_paths(checkpoint_path: str) -> tuple[Path, str, Path]:
+    """Resolve ONNX export paths from a checkpoint path."""
+    export_dir = Path(checkpoint_path).parent
+    filename = f"{export_dir.name}.onnx"
+    return export_dir, filename, export_dir / filename
+
+  def save(self, path: str, infos=None) -> None:
+    """Save checkpoint.
+
+    Extends the base implementation to persist the environment's
+    common_step_counter and to respect the ``upload_model`` config flag.
+    """
+    env_state = {"common_step_counter": self.env.unwrapped.common_step_counter}
+    infos = {**(infos or {}), "env_state": env_state}
+    # Inline base OnPolicyRunner.save() to conditionally gate W&B upload.
+    saved_dict = self.alg.save()
+    saved_dict["iter"] = self.current_learning_iteration
+    saved_dict["infos"] = infos
+    torch.save(saved_dict, path)
+    if self.cfg["upload_model"]:
+      self.logger.save_model(path, self.current_learning_iteration)
+
+  def load(
+    self,
+    path: str,
+    load_cfg: dict | None = None,
+    strict: bool = True,
+    map_location: str | None = None,
+  ) -> dict:
+    """Load checkpoint.
+
+    Extends the base implementation to:
+    1. Restore common_step_counter to preserve curricula state.
+    2. Migrate legacy checkpoints (actor.* -> mlp.*, actor_obs_normalizer.*
+      -> obs_normalizer.*) to the current format (rsl-rl>=4.0).
+    """
+    loaded_dict = torch.load(path, map_location=map_location, weights_only=False)
+
+    if "model_state_dict" in loaded_dict:
+      print(f"Detected legacy checkpoint at {path}. Migrating to new format...")
+      model_state_dict = loaded_dict.pop("model_state_dict")
+      actor_state_dict = {}
+      critic_state_dict = {}
+
+      for key, value in model_state_dict.items():
+        # Migrate actor keys.
+        if key.startswith("actor."):
+          new_key = key.replace("actor.", "mlp.")
+          actor_state_dict[new_key] = value
+        elif key.startswith("actor_obs_normalizer."):
+          new_key = key.replace("actor_obs_normalizer.", "obs_normalizer.")
+          actor_state_dict[new_key] = value
+        elif key in ["std", "log_std"]:
+          actor_state_dict[key] = value
+
+        # Migrate critic keys.
+        if key.startswith("critic."):
+          new_key = key.replace("critic.", "mlp.")
+          critic_state_dict[new_key] = value
+        elif key.startswith("critic_obs_normalizer."):
+          new_key = key.replace("critic_obs_normalizer.", "obs_normalizer.")
+          critic_state_dict[new_key] = value
+
+      loaded_dict["actor_state_dict"] = actor_state_dict
+      loaded_dict["critic_state_dict"] = critic_state_dict
+
+    # Migrate rsl-rl 4.x actor keys to 5.x distribution keys.
+    actor_sd = loaded_dict.get("actor_state_dict", {})
+    if "std" in actor_sd:
+      actor_sd["distribution.std_param"] = actor_sd.pop("std")
+    if "log_std" in actor_sd:
+      actor_sd["distribution.log_std_param"] = actor_sd.pop("log_std")
+
+    load_iteration = self.alg.load(loaded_dict, load_cfg, strict)
+    if load_iteration:
+      self.current_learning_iteration = loaded_dict["iter"]
+
+    infos = loaded_dict["infos"]
+    if infos and "env_state" in infos:
+      self.env.unwrapped.common_step_counter = infos["env_state"]["common_step_counter"]
+    return infos
diff --git a/src/mjlab/rl/spatial_softmax.py b/src/mjlab/rl/spatial_softmax.py
new file mode 100644
index 0000000..170bf45
--- /dev/null
+++ b/src/mjlab/rl/spatial_softmax.py
@@ -0,0 +1,199 @@
+"""CNN with a spatial softmax layer."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import torch
+import torch.nn as nn
+from rsl_rl.models.cnn_model import CNNModel
+from rsl_rl.models.mlp_model import MLPModel
+from rsl_rl.modules import CNN
+from tensordict import TensorDict
+
+
+class SpatialSoftmax(nn.Module):
+  """Spatial soft-argmax over feature maps.
+
+  Given input of shape ``(B, C, H, W)``, computes a softmax over each channel's spatial
+  locations and returns the expected (x, y) coordinates, yielding output shape
+  ``(B, C * 2)``.
+
+  Args:
+    height: Height of the input feature maps.
+    width: Width of the input feature maps.
+    temperature: Temperature for the spatial softmax. Lower values produce sharper
+      distributions.
+  """
+
+  def __init__(self, height: int, width: int, temperature: float = 1.0) -> None:
+    super().__init__()
+    # Create normalised coordinate grids in [-1, 1].
+    pos_x, pos_y = torch.meshgrid(
+      torch.linspace(-1.0, 1.0, height),
+      torch.linspace(-1.0, 1.0, width),
+      indexing="ij",
+    )
+    # Register as buffers so they move with the module's device.
+    self.register_buffer("pos_x", pos_x.reshape(1, 1, -1))
+    self.register_buffer("pos_y", pos_y.reshape(1, 1, -1))
+    self.temperature = temperature
+
+  def forward(self, x: torch.Tensor) -> torch.Tensor:
+    """Compute spatial soft-argmax.
+
+    Args:
+        x: Feature maps of shape ``(B, C, H, W)``.
+
+    Returns:
+        Keypoint coordinates of shape ``(B, C * 2)``.
+    """
+    B, C, H, W = x.shape
+    # Flatten spatial dims: (B, C, H*W).
+    features = x.reshape(B, C, -1)
+    # Spatial softmax.
+    weights = torch.softmax(features / self.temperature, dim=-1)
+    # Expected coordinates.
+    pos_x: torch.Tensor = self.pos_x  # type: ignore[assignment]
+    pos_y: torch.Tensor = self.pos_y  # type: ignore[assignment]
+    expected_x = (weights * pos_x).sum(dim=-1)
+    expected_y = (weights * pos_y).sum(dim=-1)
+    # Interleave: (B, C*2).
+    return torch.stack([expected_x, expected_y], dim=-1).reshape(B, C * 2)
+
+
+class SpatialSoftmaxCNN(nn.Module):
+  """CNN encoder with spatial-softmax pooling.
+
+  Wraps ``rsl_rl.modules.CNN`` (created with ``global_pool="none"``
+  and ``flatten=False``) followed by :class:`SpatialSoftmax`. Exposes the same
+  interface as ``CNN``: :attr:`output_dim` (int) and :attr:`output_channels`
+  (``None``, signalling flattened output).
+
+  Args:
+    input_dim: ``(H, W)`` of the input images.
+    input_channels: Number of input channels.
+    temperature: Temperature for the spatial softmax.
+    **cnn_kwargs: Remaining keyword arguments forwarded to ``rsl_rl.modules.CNN``.
+  """
+
+  def __init__(
+    self,
+    input_dim: tuple[int, int],
+    input_channels: int,
+    temperature: float = 1.0,
+    **cnn_kwargs: Any,
+  ) -> None:
+    super().__init__()
+    # Override pooling/flatten — spatial softmax replaces these.
+    cnn_kwargs.pop("global_pool", None)
+    cnn_kwargs.pop("flatten", None)
+    self.cnn = CNN(
+      input_dim=input_dim,
+      input_channels=input_channels,
+      global_pool="none",
+      flatten=False,
+      **cnn_kwargs,
+    )
+    # cnn.output_dim is (H, W) when flatten=False.
+    out_h, out_w = self.cnn.output_dim  # type: ignore[misc]
+    num_channels: int = self.cnn.output_channels  # type: ignore[assignment]
+    self.spatial_softmax = SpatialSoftmax(out_h, out_w, temperature)
+    self._output_dim = num_channels * 2
+
+  @property
+  def output_dim(self) -> int:
+    """Total flattened output dimension (C * 2)."""
+    return self._output_dim
+
+  @property
+  def output_channels(self) -> None:
+    """Always ``None`` (output is flattened keypoints)."""
+    return None
+
+  def forward(self, x: torch.Tensor) -> torch.Tensor:
+    features = self.cnn(x)
+    return self.spatial_softmax(features)
+
+
+class SpatialSoftmaxCNNModel(CNNModel):
+  """CNN model that uses spatial-softmax pooling.
+
+  Drop-in replacement for ``rsl_rl.models.CNNModel``.  The only difference is that each
+  CNN encoder is wrapped with :class:`SpatialSoftmaxCNN` instead of a plain ``CNN``.
+
+  The ``spatial_softmax_temperature`` parameter is extracted from ``cnn_cfg`` before
+  the remaining keys are forwarded to ``CNN``.
+  """
+
+  def __init__(
+    self,
+    obs: TensorDict,
+    obs_groups: dict[str, list[str]],
+    obs_set: str,
+    output_dim: int,
+    cnn_cfg: dict[str, dict] | dict[str, Any],
+    cnns: nn.ModuleDict | None = None,
+    hidden_dims: tuple[int] | list[int] = [256, 256, 256],  # noqa: B006
+    activation: str = "elu",
+    obs_normalization: bool = False,
+    distribution_cfg: dict[str, Any] | None = None,
+  ) -> None:
+    # Separate 1D / 2D observation groups (sets self.obs_groups_2d,
+    # obs_dims_2d, obs_channels_2d; returns 1D info for MLPModel).
+    self._get_obs_dim(obs, obs_groups, obs_set)
+
+    if cnns is not None:
+      if set(cnns.keys()) != set(self.obs_groups_2d):
+        raise ValueError(
+          "The 2D observations must be identical for all models sharing CNN encoders."
+        )
+      print(
+        "Sharing CNN encoders between models, the CNN "
+        "configurations of the receiving model are ignored."
+      )
+      _cnns = cnns
+    else:
+      # Expand a single flat config to per-group configs.
+      if not all(isinstance(v, dict) for v in cnn_cfg.values()):
+        cnn_cfg = {group: cnn_cfg for group in self.obs_groups_2d}
+      assert len(cnn_cfg) == len(self.obs_groups_2d), (
+        "The number of CNN configurations must match the "
+        "number of 2D observation groups."
+      )
+      _cnns = {}
+      for idx, obs_group in enumerate(self.obs_groups_2d):
+        group_cfg = dict(cnn_cfg[obs_group])
+        group_cfg.pop("spatial_softmax", None)
+        temperature = group_cfg.pop("spatial_softmax_temperature", 1.0)
+        _cnns[obs_group] = SpatialSoftmaxCNN(
+          input_dim=self.obs_dims_2d[idx],
+          input_channels=self.obs_channels_2d[idx],
+          temperature=temperature,
+          **group_cfg,
+        )
+
+    self.cnn_latent_dim = 0
+    for cnn in _cnns.values():
+      if cnn.output_channels is not None:
+        raise ValueError(
+          "The output of the CNN must be flattened before passing it to the MLP."
+        )
+      self.cnn_latent_dim += int(cnn.output_dim)  # type: ignore[arg-type]
+
+    MLPModel.__init__(
+      self,
+      obs=obs,
+      obs_groups=obs_groups,
+      obs_set=obs_set,
+      output_dim=output_dim,
+      hidden_dims=hidden_dims,
+      activation=activation,
+      obs_normalization=obs_normalization,
+      distribution_cfg=distribution_cfg,
+    )
+
+    if isinstance(_cnns, nn.ModuleDict):
+      self.cnns = _cnns
+    else:
+      self.cnns = nn.ModuleDict(_cnns)
diff --git a/src/mjlab/rl/vecenv_wrapper.py b/src/mjlab/rl/vecenv_wrapper.py
new file mode 100644
index 0000000..28c207b
--- /dev/null
+++ b/src/mjlab/rl/vecenv_wrapper.py
@@ -0,0 +1,107 @@
+import torch
+from rsl_rl.env import VecEnv
+from tensordict import TensorDict
+
+from mjlab.envs import ManagerBasedRlEnv, ManagerBasedRlEnvCfg
+from mjlab.utils.spaces import Space
+
+
+class RslRlVecEnvWrapper(VecEnv):
+  def __init__(
+    self,
+    env: ManagerBasedRlEnv,
+    clip_actions: float | None = None,
+  ):
+    self.env = env
+    self.clip_actions = clip_actions
+
+    self.num_envs = self.unwrapped.num_envs
+    self.device = torch.device(self.unwrapped.device)
+    self.max_episode_length = self.unwrapped.max_episode_length
+    self.num_actions = self.unwrapped.action_manager.total_action_dim
+    self._modify_action_space()
+
+    # Reset at the start since rsl_rl does not call reset.
+    self.env.reset()
+
+  @property
+  def cfg(self) -> ManagerBasedRlEnvCfg:
+    return self.unwrapped.cfg
+
+  @property
+  def render_mode(self) -> str | None:
+    return self.env.render_mode
+
+  @property
+  def observation_space(self) -> Space:
+    return self.env.observation_space
+
+  @property
+  def action_space(self) -> Space:
+    return self.env.action_space
+
+  @classmethod
+  def class_name(cls) -> str:
+    return cls.__name__
+
+  @property
+  def unwrapped(self) -> ManagerBasedRlEnv:
+    return self.env.unwrapped
+
+  # Properties.
+
+  @property
+  def episode_length_buf(self) -> torch.Tensor:
+    return self.unwrapped.episode_length_buf
+
+  @episode_length_buf.setter
+  def episode_length_buf(self, value: torch.Tensor) -> None:  # pyright: ignore[reportIncompatibleVariableOverride]
+    self.unwrapped.episode_length_buf = value
+
+  def seed(self, seed: int = -1) -> int:
+    return self.unwrapped.seed(seed)
+
+  def get_observations(self) -> TensorDict:
+    obs_dict = self.unwrapped.observation_manager.compute()
+    return TensorDict(obs_dict, batch_size=[self.num_envs])
+
+  def reset(self) -> tuple[TensorDict, dict]:
+    obs_dict, extras = self.env.reset()
+    return TensorDict(obs_dict, batch_size=[self.num_envs]), extras
+
+  def step(
+    self, actions: torch.Tensor
+  ) -> tuple[TensorDict, torch.Tensor, torch.Tensor, dict]:
+    if self.clip_actions is not None:
+      actions = torch.clamp(actions, -self.clip_actions, self.clip_actions)
+    obs_dict, rew, terminated, truncated, extras = self.env.step(actions)
+    term_or_trunc = terminated | truncated
+    assert isinstance(rew, torch.Tensor)
+    assert isinstance(term_or_trunc, torch.Tensor)
+    dones = term_or_trunc.to(dtype=torch.long)
+    if not self.cfg.is_finite_horizon:
+      extras["time_outs"] = truncated
+    return (
+      TensorDict(obs_dict, batch_size=[self.num_envs]),
+      rew,
+      dones,
+      extras,
+    )
+
+  def close(self) -> None:
+    return self.env.close()
+
+  # Private methods.
+
+  def _modify_action_space(self) -> None:
+    if self.clip_actions is None:
+      return
+
+    from mjlab.utils.spaces import Box, batch_space
+
+    self.unwrapped.single_action_space = Box(
+      shape=(self.num_actions,), low=-self.clip_actions, high=self.clip_actions
+    )
+    self.unwrapped.action_space = batch_space(
+      self.unwrapped.single_action_space, self.num_envs
+    )
diff --git a/src/mjlab/scene/__init__.py b/src/mjlab/scene/__init__.py
new file mode 100644
index 0000000..3cc68e6
--- /dev/null
+++ b/src/mjlab/scene/__init__.py
@@ -0,0 +1,2 @@
+from mjlab.scene.scene import Scene as Scene
+from mjlab.scene.scene import SceneCfg as SceneCfg
diff --git a/src/mjlab/scene/scene.py b/src/mjlab/scene/scene.py
new file mode 100644
index 0000000..68e0643
--- /dev/null
+++ b/src/mjlab/scene/scene.py
@@ -0,0 +1,274 @@
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable
+
+import mujoco
+import mujoco_warp as mjwarp
+import numpy as np
+import torch
+
+from mjlab.entity import Entity, EntityCfg
+from mjlab.entity.variants import VariantMetadata
+from mjlab.sensor import BuiltinSensor, RayCastSensor, Sensor, SensorCfg
+from mjlab.sensor.camera_sensor import CameraSensor
+from mjlab.sensor.sensor_context import SensorContext
+from mjlab.terrains.terrain_entity import TerrainEntity, TerrainEntityCfg
+from mjlab.utils.spec import export_spec, non_default_option_fields
+
+_SCENE_XML = Path(__file__).parent / "scene.xml"
+
+
+@dataclass(kw_only=True)
+class SceneCfg:
+  """Configuration for a simulation scene."""
+
+  num_envs: int = 1
+  """Number of parallel environments."""
+
+  env_spacing: float = 2.0
+  """Spacing between environment origins in meters."""
+
+  terrain: TerrainEntityCfg | None = None
+  """Terrain configuration. If ``None``, no terrain is added."""
+
+  entities: dict[str, EntityCfg] = field(default_factory=dict)
+  """Mapping of entity names to their configurations."""
+
+  sensors: tuple[SensorCfg, ...] = field(default_factory=tuple)
+  """Sensor configurations to attach to the scene."""
+
+  extent: float | None = None
+  """Override for ``mjModel.stat.extent``. If ``None``, MuJoCo computes
+  it automatically."""
+
+  spec_fn: Callable[[mujoco.MjSpec], None] | None = None
+  """Optional callback to modify the ``MjSpec`` after entities and sensors
+  have been added but before compilation."""
+
+
+class Scene:
+  def __init__(self, scene_cfg: SceneCfg, device: str) -> None:
+    self._cfg = scene_cfg
+    self._device = device
+    self._entities: dict[str, Entity] = {}
+    self._sensors: dict[str, Sensor] = {}
+    self._terrain: TerrainEntity | None = None
+    self._default_env_origins: torch.Tensor | None = None
+    self._sensor_context: SensorContext | None = None
+
+    self._spec = mujoco.MjSpec.from_file(str(_SCENE_XML))
+    if self._cfg.extent is not None:
+      self._spec.stat.extent = self._cfg.extent
+    self._add_terrain()
+    self._add_entities()
+    self._add_sensors()
+    if self._cfg.spec_fn is not None:
+      self._cfg.spec_fn(self._spec)
+
+  def compile(self) -> mujoco.MjModel:
+    return self._spec.compile()
+
+  def write(self, output_dir: Path, *, zip: bool = False) -> None:
+    """Write the scene XML and mesh assets to a directory.
+
+    Creates ``scene.xml`` and an ``assets/`` subdirectory containing mesh files
+    referenced by the scene. When *zip* is True the directory is compressed into a
+    ``.zip`` archive and the directory is removed. Operates on a copy of the spec to
+    avoid mutation.
+
+    Args:
+      output_dir: Destination directory (created if it doesn't exist).
+      zip: If True, produce ``<output_dir>.zip`` instead of a directory.
+    """
+    export_spec(self._spec, output_dir, zip=zip)
+
+  def to_zip(self, path: Path) -> None:
+    """Deprecated. Use ``write(output_dir, zip=True)`` instead."""
+    warnings.warn(
+      "Scene.to_zip() is deprecated. Use Scene.write(path, zip=True).",
+      DeprecationWarning,
+      stacklevel=2,
+    )
+    self.write(path, zip=True)
+
+  # Attributes.
+
+  @property
+  def spec(self) -> mujoco.MjSpec:
+    return self._spec
+
+  @property
+  def env_origins(self) -> torch.Tensor:
+    if self._terrain is not None:
+      assert self._terrain.env_origins is not None
+      return self._terrain.env_origins
+    assert self._default_env_origins is not None
+    return self._default_env_origins
+
+  @property
+  def env_spacing(self) -> float:
+    return self._cfg.env_spacing
+
+  @property
+  def entities(self) -> dict[str, Entity]:
+    return self._entities
+
+  @property
+  def sensors(self) -> dict[str, Sensor]:
+    return self._sensors
+
+  @property
+  def terrain(self) -> TerrainEntity | None:
+    return self._terrain
+
+  @property
+  def num_envs(self) -> int:
+    return self._cfg.num_envs
+
+  @property
+  def device(self) -> str:
+    return self._device
+
+  def collect_variant_info(
+    self,
+  ) -> list[tuple[str, VariantMetadata]]:
+    """Collect variant metadata for entities with mesh variants."""
+    result: list[tuple[str, VariantMetadata]] = []
+    for name, ent in self._entities.items():
+      if ent.variant_metadata is not None:
+        result.append((f"{name}/", ent.variant_metadata))
+    return result
+
+  def __getitem__(self, key: str) -> Any:
+    if key in self._sensors:
+      return self._sensors[key]
+    if key in self._entities:
+      return self._entities[key]
+
+    # Not found, raise helpful error.
+    available = list(self._entities.keys()) + list(self._sensors.keys())
+    raise KeyError(f"Scene element '{key}' not found. Available: {available}")
+
+  # Methods.
+
+  @property
+  def sensor_context(self) -> SensorContext | None:
+    """Shared sensing resources, or None if no cameras/raycasts."""
+    return self._sensor_context
+
+  def initialize(
+    self,
+    mj_model: mujoco.MjModel,
+    model: mjwarp.Model,
+    data: mjwarp.Data,
+  ):
+    self._default_env_origins = torch.zeros(
+      (self._cfg.num_envs, 3), device=self._device, dtype=torch.float32
+    )
+    for ent in self._entities.values():
+      ent.initialize(mj_model, model, data, self._device)
+    for sensor in self._sensors.values():
+      sensor.initialize(mj_model, model, data, self._device)
+
+    # Create SensorContext if any sensors require it.
+    ctx_sensors = [s for s in self._sensors.values() if s.requires_sensor_context]
+    if ctx_sensors:
+      camera_sensors = [s for s in ctx_sensors if isinstance(s, CameraSensor)]
+      raycast_sensors = [s for s in ctx_sensors if isinstance(s, RayCastSensor)]
+      self._sensor_context = SensorContext(
+        mj_model=mj_model,
+        model=model,
+        data=data,
+        camera_sensors=camera_sensors,
+        raycast_sensors=raycast_sensors,
+        device=self._device,
+      )
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    for ent in self._entities.values():
+      ent.reset(env_ids)
+    for sensor in self._sensors.values():
+      sensor.reset(env_ids)
+
+  def update(self, dt: float) -> None:
+    for ent in self._entities.values():
+      ent.update(dt)
+    for sensor in self._sensors.values():
+      sensor.update(dt)
+
+  def write_data_to_sim(self) -> None:
+    for ent in self._entities.values():
+      ent.write_data_to_sim()
+
+  # Private methods.
+
+  def _add_entities(self) -> None:
+    # Collect keyframes from each entity to merge into a single scene keyframe.
+    # Order matters: qpos/ctrl are concatenated in entity iteration order.
+    key_qpos: list[np.ndarray] = []
+    key_ctrl: list[np.ndarray] = []
+    for ent_name, ent_cfg in self._cfg.entities.items():
+      ent = ent_cfg.build()
+      self._entities[ent_name] = ent
+      # Extract keyframe before attach (must delete before attach to avoid corruption).
+      if ent.spec.keys:
+        if len(ent.spec.keys) > 1:
+          warnings.warn(
+            f"Entity '{ent_name}' has {len(ent.spec.keys)} keyframes; only the "
+            "first one will be used.",
+            stacklevel=2,
+          )
+        key_qpos.append(np.array(ent.spec.keys[0].qpos))
+        key_ctrl.append(np.array(ent.spec.keys[0].ctrl))
+        ent.spec.delete(ent.spec.keys[0])
+      non_default = non_default_option_fields(ent.spec.option)
+      if non_default:
+        fields = ", ".join(non_default)
+        warnings.warn(
+          f"Entity '{ent_name}' has non-default <option> fields ({fields}) that will"
+          " not be propagated by MjSpec.attach(). Use MujocoCfg instead.",
+          stacklevel=2,
+        )
+      frame = self._spec.worldbody.add_frame()
+      self._spec.attach(ent.spec, prefix=f"{ent_name}/", frame=frame)
+    # Add merged keyframe to scene spec.
+    if key_qpos:
+      combined_qpos = np.concatenate(key_qpos)
+      combined_ctrl = np.concatenate(key_ctrl)
+      self._spec.add_key(
+        name="init_state",
+        qpos=combined_qpos.tolist(),
+        ctrl=combined_ctrl.tolist(),
+      )
+
+  def _add_terrain(self) -> None:
+    if self._cfg.terrain is None:
+      return
+    self._cfg.terrain.num_envs = self._cfg.num_envs
+    self._cfg.terrain.env_spacing = self._cfg.env_spacing
+    terrain = TerrainEntity(self._cfg.terrain, device=self._device)
+    self._terrain = terrain
+    self._entities["terrain"] = terrain
+    non_default = non_default_option_fields(terrain.spec.option)
+    if non_default:
+      fields = ", ".join(non_default)
+      warnings.warn(
+        f"Terrain has non-default <option> fields ({fields}) that will not be"
+        " propagated by MjSpec.attach(). Use MujocoCfg instead.",
+        stacklevel=2,
+      )
+    frame = self._spec.worldbody.add_frame()
+    self._spec.attach(terrain.spec, prefix="", frame=frame)
+
+  def _add_sensors(self) -> None:
+    for sensor_cfg in self._cfg.sensors:
+      sns = sensor_cfg.build()
+      sns.edit_spec(self._spec, self._entities)
+      self._sensors[sensor_cfg.prefixed_name] = sns
+
+    for sns in self._spec.sensors:
+      if sns.name not in self._sensors:
+        self._sensors[sns.name] = BuiltinSensor.from_existing(sns.name)
diff --git a/src/mjlab/scene/scene.xml b/src/mjlab/scene/scene.xml
new file mode 100644
index 0000000..cb10d56
--- /dev/null
+++ b/src/mjlab/scene/scene.xml
@@ -0,0 +1,12 @@
+<!-- Visualization defaults for mjlab scenes. Only applies when using native MuJoCo viewer. -->
+<mujoco model="mjlab scene">
+  <visual>
+    <headlight diffuse="0.6 0.6 0.6" ambient="0.3 0.3 0.3" specular="0 0 0"/>
+    <rgba force="1 0 0 1" haze="0.15 0.25 0.35 1"/>
+    <global azimuth="135" elevation="-25" offwidth="1920" offheight="1080"/>
+    <map force="0.005"/>
+    <scale forcewidth="0.25" contactwidth="0.4" contactheight="0.15" framelength="5.0" framewidth="0.3"/>
+    <quality shadowsize="8192"/>
+  </visual>
+  <statistic meansize="0.03"/>
+</mujoco>
diff --git a/src/mjlab/scripts/_cli.py b/src/mjlab/scripts/_cli.py
new file mode 100644
index 0000000..b2594fe
--- /dev/null
+++ b/src/mjlab/scripts/_cli.py
@@ -0,0 +1,18 @@
+"""Shared helpers for CLI entrypoints."""
+
+import sys
+
+
+def maybe_print_top_level_help(prog: str) -> None:
+  """Print a top-level usage message and exit if argv is bare -h/--help.
+
+  The ``train`` and ``play`` entrypoints use a two-stage tyro parse with
+  ``add_help=False`` on the first stage, so ``prog --help`` otherwise
+  produces no output. This handles that case explicitly.
+  """
+  if len(sys.argv) >= 2 and sys.argv[1] in ("-h", "--help"):
+    print(f"usage: {prog} <TASK> [OPTIONS]")
+    print()
+    print(f"Run '{prog} <TASK> --help' for task-specific options.")
+    print("Run 'uv run list-envs' to list available tasks.")
+    sys.exit(0)
diff --git a/src/mjlab/scripts/csv_to_npz.py b/src/mjlab/scripts/csv_to_npz.py
new file mode 100644
index 0000000..ac5a13b
--- /dev/null
+++ b/src/mjlab/scripts/csv_to_npz.py
@@ -0,0 +1,436 @@
+from typing import Any
+
+import numpy as np
+import torch
+import tyro
+from tqdm import tqdm
+
+import mjlab
+from mjlab.entity import Entity
+from mjlab.scene import Scene
+from mjlab.sim.sim import Simulation, SimulationCfg
+from mjlab.tasks.tracking.config.g1.env_cfgs import unitree_g1_flat_tracking_env_cfg
+from mjlab.utils.lab_api.math import (
+  axis_angle_from_quat,
+  quat_conjugate,
+  quat_mul,
+  quat_slerp,
+)
+from mjlab.viewer.offscreen_renderer import OffscreenRenderer
+from mjlab.viewer.viewer_config import ViewerConfig
+
+
+class MotionLoader:
+  def __init__(
+    self,
+    motion_file: str,
+    input_fps: int,
+    output_fps: int,
+    device: torch.device | str,
+    line_range: tuple[int, int] | None = None,
+  ):
+    self.motion_file = motion_file
+    self.input_fps = input_fps
+    self.output_fps = output_fps
+    self.input_dt = 1.0 / self.input_fps
+    self.output_dt = 1.0 / self.output_fps
+    self.current_idx = 0
+    self.device = device
+    self.line_range = line_range
+    self._load_motion()
+    self._interpolate_motion()
+    self._compute_velocities()
+
+  def _load_motion(self):
+    """Loads the motion from the csv file."""
+    if self.line_range is None:
+      motion = torch.from_numpy(np.loadtxt(self.motion_file, delimiter=","))
+    else:
+      motion = torch.from_numpy(
+        np.loadtxt(
+          self.motion_file,
+          delimiter=",",
+          skiprows=self.line_range[0] - 1,
+          max_rows=self.line_range[1] - self.line_range[0] + 1,
+        )
+      )
+    motion = motion.to(torch.float32).to(self.device)
+    # motion[:, 2] -= 0.05
+    self.motion_base_poss_input = motion[:, :3]
+    self.motion_base_rots_input = motion[:, 3:7]
+    self.motion_base_rots_input = self.motion_base_rots_input[
+      :, [3, 0, 1, 2]
+    ]  # convert to wxyz
+    self.motion_dof_poss_input = motion[:, 7:]
+
+    self.input_frames = motion.shape[0]
+    self.duration = (self.input_frames - 1) * self.input_dt
+
+  def _interpolate_motion(self):
+    """Interpolates the motion to the output fps."""
+    times = torch.arange(
+      0, self.duration, self.output_dt, device=self.device, dtype=torch.float32
+    )
+    self.output_frames = times.shape[0]
+    index_0, index_1, blend = self._compute_frame_blend(times)
+    self.motion_base_poss = self._lerp(
+      self.motion_base_poss_input[index_0],
+      self.motion_base_poss_input[index_1],
+      blend.unsqueeze(1),
+    )
+    self.motion_base_rots = self._slerp(
+      self.motion_base_rots_input[index_0],
+      self.motion_base_rots_input[index_1],
+      blend,
+    )
+    self.motion_dof_poss = self._lerp(
+      self.motion_dof_poss_input[index_0],
+      self.motion_dof_poss_input[index_1],
+      blend.unsqueeze(1),
+    )
+    print(
+      f"Motion interpolated, input frames: {self.input_frames}, "
+      f"input fps: {self.input_fps}, "
+      f"output frames: {self.output_frames}, "
+      f"output fps: {self.output_fps}"
+    )
+
+  def _lerp(
+    self, a: torch.Tensor, b: torch.Tensor, blend: torch.Tensor
+  ) -> torch.Tensor:
+    """Linear interpolation between two tensors."""
+    return a * (1 - blend) + b * blend
+
+  def _slerp(
+    self, a: torch.Tensor, b: torch.Tensor, blend: torch.Tensor
+  ) -> torch.Tensor:
+    """Spherical linear interpolation between two quaternions."""
+    slerped_quats = torch.zeros_like(a)
+    for i in range(a.shape[0]):
+      slerped_quats[i] = quat_slerp(a[i], b[i], float(blend[i]))
+    return slerped_quats
+
+  def _compute_frame_blend(
+    self, times: torch.Tensor
+  ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    """Computes the frame blend for the motion."""
+    phase = times / self.duration
+    index_0 = (phase * (self.input_frames - 1)).floor().long()
+    index_1 = torch.minimum(index_0 + 1, torch.tensor(self.input_frames - 1))
+    blend = phase * (self.input_frames - 1) - index_0
+    return index_0, index_1, blend
+
+  def _compute_velocities(self):
+    """Computes the velocities of the motion."""
+    self.motion_base_lin_vels = torch.gradient(
+      self.motion_base_poss, spacing=self.output_dt, dim=0
+    )[0]
+    self.motion_dof_vels = torch.gradient(
+      self.motion_dof_poss, spacing=self.output_dt, dim=0
+    )[0]
+    self.motion_base_ang_vels = self._so3_derivative(
+      self.motion_base_rots, self.output_dt
+    )
+
+  def _so3_derivative(self, rotations: torch.Tensor, dt: float) -> torch.Tensor:
+    """Computes the derivative of a sequence of SO3 rotations.
+
+    Args:
+      rotations: shape (B, 4).
+      dt: time step.
+    Returns:
+      shape (B, 3).
+    """
+    q_prev, q_next = rotations[:-2], rotations[2:]
+    q_rel = quat_mul(q_next, quat_conjugate(q_prev))  # shape (B−2, 4)
+
+    omega = axis_angle_from_quat(q_rel) / (2.0 * dt)  # shape (B−2, 3)
+    omega = torch.cat(
+      [omega[:1], omega, omega[-1:]], dim=0
+    )  # repeat first and last sample
+    return omega
+
+  def get_next_state(
+    self,
+  ) -> tuple[
+    tuple[
+      torch.Tensor,
+      torch.Tensor,
+      torch.Tensor,
+      torch.Tensor,
+      torch.Tensor,
+      torch.Tensor,
+    ],
+    bool,
+  ]:
+    """Gets the next state of the motion."""
+    state = (
+      self.motion_base_poss[self.current_idx : self.current_idx + 1],
+      self.motion_base_rots[self.current_idx : self.current_idx + 1],
+      self.motion_base_lin_vels[self.current_idx : self.current_idx + 1],
+      self.motion_base_ang_vels[self.current_idx : self.current_idx + 1],
+      self.motion_dof_poss[self.current_idx : self.current_idx + 1],
+      self.motion_dof_vels[self.current_idx : self.current_idx + 1],
+    )
+    self.current_idx += 1
+    reset_flag = False
+    if self.current_idx >= self.output_frames:
+      self.current_idx = 0
+      reset_flag = True
+    return state, reset_flag
+
+
+def run_sim(
+  sim: Simulation,
+  scene: Scene,
+  joint_names,
+  input_file,
+  input_fps,
+  output_fps,
+  output_name,
+  render,
+  line_range,
+  renderer: OffscreenRenderer | None = None,
+):
+  motion = MotionLoader(
+    motion_file=input_file,
+    input_fps=input_fps,
+    output_fps=output_fps,
+    device=sim.device,
+    line_range=line_range,
+  )
+
+  robot: Entity = scene["robot"]
+  robot_joint_indexes = robot.find_joints(joint_names, preserve_order=True)[0]
+
+  log: dict[str, Any] = {
+    "fps": [output_fps],
+    "joint_pos": [],
+    "joint_vel": [],
+    "body_pos_w": [],
+    "body_quat_w": [],
+    "body_lin_vel_w": [],
+    "body_ang_vel_w": [],
+  }
+  file_saved = False
+
+  frames = []
+  scene.reset()
+
+  print(f"\nStarting simulation with {motion.output_frames} frames...")
+  if render:
+    print("Rendering enabled - generating video frames...")
+
+  # Create progress bar
+  pbar = tqdm(
+    total=motion.output_frames,
+    desc="Processing frames",
+    unit="frame",
+    ncols=100,
+    bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}]",
+  )
+
+  frame_count = 0
+  while not file_saved:
+    (
+      (
+        motion_base_pos,
+        motion_base_rot,
+        motion_base_lin_vel,
+        motion_base_ang_vel,
+        motion_dof_pos,
+        motion_dof_vel,
+      ),
+      reset_flag,
+    ) = motion.get_next_state()
+
+    root_states = robot.data.default_root_state.clone()
+    root_states[:, 0:3] = motion_base_pos
+    root_states[:, :2] += scene.env_origins[:, :2]
+    root_states[:, 3:7] = motion_base_rot
+    root_states[:, 7:10] = motion_base_lin_vel
+    root_states[:, 10:] = motion_base_ang_vel
+    robot.write_root_state_to_sim(root_states)
+
+    joint_pos = robot.data.default_joint_pos.clone()
+    joint_vel = robot.data.default_joint_vel.clone()
+    joint_pos[:, robot_joint_indexes] = motion_dof_pos
+    joint_vel[:, robot_joint_indexes] = motion_dof_vel
+    robot.write_joint_state_to_sim(joint_pos, joint_vel)
+
+    sim.forward()
+    scene.update(sim.mj_model.opt.timestep)
+    if render and renderer is not None:
+      renderer.update(sim.data)
+      frames.append(renderer.render())
+
+    if not file_saved:
+      log["joint_pos"].append(robot.data.joint_pos[0, :].cpu().numpy().copy())
+      log["joint_vel"].append(robot.data.joint_vel[0, :].cpu().numpy().copy())
+      log["body_pos_w"].append(robot.data.body_link_pos_w[0, :].cpu().numpy().copy())
+      log["body_quat_w"].append(robot.data.body_link_quat_w[0, :].cpu().numpy().copy())
+      log["body_lin_vel_w"].append(
+        robot.data.body_link_lin_vel_w[0, :].cpu().numpy().copy()
+      )
+      log["body_ang_vel_w"].append(
+        robot.data.body_link_ang_vel_w[0, :].cpu().numpy().copy()
+      )
+
+      torch.testing.assert_close(
+        robot.data.body_link_lin_vel_w[0, 0], motion_base_lin_vel[0]
+      )
+      torch.testing.assert_close(
+        robot.data.body_link_ang_vel_w[0, 0], motion_base_ang_vel[0]
+      )
+
+      frame_count += 1
+      pbar.update(1)
+
+      if frame_count % 100 == 0:  # Update every 100 frames to avoid spam
+        elapsed_time = frame_count / output_fps
+        pbar.set_description(f"Processing frames (t={elapsed_time:.1f}s)")
+
+      if reset_flag and not file_saved:
+        file_saved = True
+        pbar.close()
+
+        print("\nStacking arrays and saving data...")
+        for k in (
+          "joint_pos",
+          "joint_vel",
+          "body_pos_w",
+          "body_quat_w",
+          "body_lin_vel_w",
+          "body_ang_vel_w",
+        ):
+          log[k] = np.stack(log[k], axis=0)
+
+        print("Saving to /tmp/motion.npz...")
+        np.savez("/tmp/motion.npz", **log)
+
+        print("Uploading to Weights & Biases...")
+        import wandb
+
+        COLLECTION = output_name
+        run = wandb.init(project="csv_to_npz", name=COLLECTION)
+        print(f"[INFO]: Logging motion to wandb: {COLLECTION}")
+        REGISTRY = "motions"
+        logged_artifact = run.log_artifact(
+          artifact_or_path="/tmp/motion.npz", name=COLLECTION, type=REGISTRY
+        )
+        run.link_artifact(
+          artifact=logged_artifact,
+          target_path=f"wandb-registry-{REGISTRY}/{COLLECTION}",
+        )
+        print(f"[INFO]: Motion saved to wandb registry: {REGISTRY}/{COLLECTION}")
+
+        if render:
+          import mediapy as media
+
+          print("Creating video...")
+          media.write_video("./motion.mp4", frames, fps=output_fps)
+
+          print("Logging video to wandb...")
+          wandb.log({"motion_video": wandb.Video("./motion.mp4", format="mp4")})
+
+        wandb.finish()
+
+
+def main(
+  input_file: str,
+  output_name: str,
+  input_fps: float = 30.0,
+  output_fps: float = 50.0,
+  device: str = "cuda:0",
+  render: bool = False,
+  line_range: tuple[int, int] | None = None,
+):
+  """Replay motion from CSV file and output to npz file.
+
+  Args:
+    input_file: Path to the input CSV file.
+    output_name: Path to the output npz file.
+    input_fps: Frame rate of the CSV file.
+    output_fps: Desired output frame rate.
+    device: Device to use.
+    render: Whether to render the simulation and save a video.
+    line_range: Range of lines to process from the CSV file.
+  """
+  if device.startswith("cuda") and not torch.cuda.is_available():
+    print("[WARNING]: CUDA is not available. Falling back to CPU. This may be slow.")
+    device = "cpu"
+
+  sim_cfg = SimulationCfg()
+  sim_cfg.mujoco.timestep = 1.0 / output_fps
+
+  scene = Scene(unitree_g1_flat_tracking_env_cfg().scene, device=device)
+  model = scene.compile()
+
+  sim = Simulation(num_envs=1, cfg=sim_cfg, model=model, device=device)
+
+  scene.initialize(sim.mj_model, sim.model, sim.data)
+
+  renderer = None
+  if render:
+    viewer_cfg = ViewerConfig(
+      height=480,
+      width=640,
+      origin_type=ViewerConfig.OriginType.ASSET_ROOT,
+      entity_name="robot",
+      distance=2.0,
+      elevation=-5.0,
+      azimuth=20,
+    )
+    renderer = OffscreenRenderer(
+      model=sim.mj_model,
+      cfg=viewer_cfg,
+      scene=scene,
+    )
+    renderer.initialize()
+
+  run_sim(
+    sim=sim,
+    scene=scene,
+    joint_names=[
+      "left_hip_pitch_joint",
+      "left_hip_roll_joint",
+      "left_hip_yaw_joint",
+      "left_knee_joint",
+      "left_ankle_pitch_joint",
+      "left_ankle_roll_joint",
+      "right_hip_pitch_joint",
+      "right_hip_roll_joint",
+      "right_hip_yaw_joint",
+      "right_knee_joint",
+      "right_ankle_pitch_joint",
+      "right_ankle_roll_joint",
+      "waist_yaw_joint",
+      "waist_roll_joint",
+      "waist_pitch_joint",
+      "left_shoulder_pitch_joint",
+      "left_shoulder_roll_joint",
+      "left_shoulder_yaw_joint",
+      "left_elbow_joint",
+      "left_wrist_roll_joint",
+      "left_wrist_pitch_joint",
+      "left_wrist_yaw_joint",
+      "right_shoulder_pitch_joint",
+      "right_shoulder_roll_joint",
+      "right_shoulder_yaw_joint",
+      "right_elbow_joint",
+      "right_wrist_roll_joint",
+      "right_wrist_pitch_joint",
+      "right_wrist_yaw_joint",
+    ],
+    input_fps=input_fps,
+    input_file=input_file,
+    output_fps=output_fps,
+    output_name=output_name,
+    render=render,
+    line_range=line_range,
+    renderer=renderer,
+  )
+
+
+if __name__ == "__main__":
+  tyro.cli(main, config=mjlab.TYRO_FLAGS)
diff --git a/src/mjlab/scripts/demo.py b/src/mjlab/scripts/demo.py
new file mode 100644
index 0000000..b0c19ae
--- /dev/null
+++ b/src/mjlab/scripts/demo.py
@@ -0,0 +1,41 @@
+"""Script to run a tracking demo with a pretrained policy.
+
+This demo downloads a pretrained checkpoint and motion file from cloud storage
+and launches an interactive viewer with a humanoid robot performing a cartwheel.
+"""
+
+import tyro
+
+import mjlab
+from mjlab.scripts.gcs import ensure_default_checkpoint, ensure_default_motion
+from mjlab.scripts.play import PlayConfig, run_play
+
+
+def main() -> None:
+  """Run demo with pretrained tracking policy."""
+  print("🎮 Setting up mjlab demo with pretrained tracking policy...")
+
+  try:
+    checkpoint_path = ensure_default_checkpoint()
+    motion_path = ensure_default_motion()
+  except RuntimeError as e:
+    print(f"❌ Failed to download demo assets: {e}")
+    print("Please check your internet connection and try again.")
+    return
+
+  args = tyro.cli(
+    PlayConfig,
+    default=PlayConfig(
+      checkpoint_file=checkpoint_path,
+      motion_file=motion_path,
+      num_envs=8,
+      viewer="viser",
+      _demo_mode=True,
+    ),
+    config=mjlab.TYRO_FLAGS,
+  )
+  run_play("Mjlab-Tracking-Flat-Unitree-G1", args)
+
+
+if __name__ == "__main__":
+  main()
diff --git a/src/mjlab/scripts/export_scene.py b/src/mjlab/scripts/export_scene.py
new file mode 100644
index 0000000..941be6a
--- /dev/null
+++ b/src/mjlab/scripts/export_scene.py
@@ -0,0 +1,81 @@
+"""Export a task scene or asset_zoo entity to a directory."""
+
+from __future__ import annotations
+
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+import tyro
+import tyro.conf
+
+import mjlab
+import mjlab.tasks  # noqa: F401
+from mjlab.scene import Scene, SceneCfg
+from mjlab.tasks.registry import list_tasks, load_env_cfg
+from mjlab.utils.lab_api.string import string_to_callable
+
+ENTITY_ALIASES: dict[str, str] = {
+  "g1": "mjlab.asset_zoo.robots:get_g1_robot_cfg",
+  "go1": "mjlab.asset_zoo.robots:get_go1_robot_cfg",
+  "yam": "mjlab.asset_zoo.robots:get_yam_robot_cfg",
+}
+
+
+@dataclass
+class ExportSceneCfg:
+  target: tyro.conf.Positional[str]
+  """Task ID, entity alias (g1, go1, yam), or import path (pkg.module:get_cfg)."""
+
+  output_dir: str = "export"
+  """Output directory."""
+
+  zip: bool = False
+  """Compress into a zip archive."""
+
+
+def export_scene(cfg: ExportSceneCfg) -> None:
+  """Export a task scene or entity to a directory."""
+  task_ids = list_tasks()
+  target = ENTITY_ALIASES.get(cfg.target, cfg.target)
+
+  if target in task_ids:
+    env_cfg = load_env_cfg(target)
+    scene = Scene(env_cfg.scene, device="cpu")
+  elif ":" in target:
+    try:
+      factory = string_to_callable(target)
+    except (ValueError, ImportError) as e:
+      print(f"Error: {e}")
+      return
+    entity_cfg = factory()
+    scene_cfg = SceneCfg(entities={"robot": entity_cfg})
+    scene = Scene(scene_cfg, device="cpu")
+  else:
+    print(f"Unknown target: {cfg.target}\n")
+    print("Available task IDs:")
+    for tid in task_ids:
+      print(f"  {tid}")
+    print("\nAvailable entity aliases:")
+    for name in sorted(ENTITY_ALIASES):
+      print(f"  {name}")
+    print("\nYou can also pass an import path, e.g. my_pkg.robots:get_my_robot_cfg")
+    return
+
+  output_dir = Path(cfg.output_dir)
+  if output_dir.exists():
+    shutil.rmtree(output_dir)
+  scene.write(output_dir, zip=cfg.zip)
+  if cfg.zip:
+    print(f"Exported to {output_dir.with_suffix('.zip')}")
+  else:
+    print(f"Exported to {output_dir}")
+
+
+def main():
+  cfg = tyro.cli(ExportSceneCfg, config=mjlab.TYRO_FLAGS)
+  export_scene(cfg)
+
+
+if __name__ == "__main__":
+  main()
diff --git a/src/mjlab/scripts/gcs.py b/src/mjlab/scripts/gcs.py
new file mode 100644
index 0000000..109d250
--- /dev/null
+++ b/src/mjlab/scripts/gcs.py
@@ -0,0 +1,107 @@
+import hashlib
+import tempfile
+from pathlib import Path
+from typing import TypedDict
+
+import requests
+from tqdm import tqdm
+
+CACHE_DIR = Path(tempfile.gettempdir()) / "mjlab_cache"
+
+
+class AssetInfo(TypedDict):
+  url: str
+  sha256: str
+  path: Path
+
+
+ASSETS: dict[str, AssetInfo] = {
+  "demo_ckpt.pt": {
+    "url": "https://storage.googleapis.com/mjlab_beta/model_49999.pt",
+    "sha256": "f1bc404f5165b833a3933ac98ff223450392b78df3eb76b0c36cd1360ff22319",
+    "path": CACHE_DIR / "demo_ckpt.pt",
+  },
+  "demo_motion.npz": {
+    "url": "https://storage.googleapis.com/mjlab_beta/lafan_dance1_subject1.npz",
+    "sha256": "f08d15d4b5bb605e17b6928ccdb44ae6ce7bf2038111e8b145f12a176cd096d4",
+    "path": CACHE_DIR / "lafan1_dance1_subject1_demo_motion.npz",
+  },
+}
+
+
+def download_with_progress(url: str, path: Path) -> None:
+  """Download file with progress bar."""
+  response = requests.get(url, stream=True)
+  response.raise_for_status()
+
+  total_size = int(response.headers.get("content-length", 0))
+
+  with (
+    open(path, "wb") as f,
+    tqdm(
+      desc=path.name,
+      total=total_size,
+      unit="B",
+      unit_scale=True,
+      unit_divisor=1024,
+    ) as pbar,
+  ):
+    for chunk in response.iter_content(chunk_size=8192):
+      size = f.write(chunk)
+      pbar.update(size)
+
+
+def verify_file_hash(path: Path, expected_hash: str) -> bool:
+  """Verify file integrity using SHA256."""
+  if not path.exists():
+    return False
+
+  sha256_hash = hashlib.sha256()
+  with open(path, "rb") as f:
+    for chunk in iter(lambda: f.read(4096), b""):
+      sha256_hash.update(chunk)
+
+  return sha256_hash.hexdigest() == expected_hash
+
+
+def ensure_asset_downloaded(asset_name: str, force_download: bool = False) -> Path:
+  """Download and verify an asset if needed."""
+  if asset_name not in ASSETS:
+    raise ValueError(f"Unknown asset: {asset_name}")
+
+  asset_info = ASSETS[asset_name]
+  local_path = Path(asset_info["path"])
+
+  if not force_download and verify_file_hash(local_path, asset_info["sha256"]):
+    print(f"✓ {asset_name} already cached at {local_path}")
+    return local_path
+
+  print(f"📥 Downloading {asset_name}...")
+  local_path.parent.mkdir(parents=True, exist_ok=True)
+
+  try:
+    download_with_progress(asset_info["url"], local_path)
+
+    if not verify_file_hash(local_path, asset_info["sha256"]):
+      local_path.unlink()  # Delete corrupted file
+      raise RuntimeError(f"Downloaded {asset_name} failed hash verification")
+
+    print(f"✅ {asset_name} cached at {local_path}")
+    return local_path
+
+  except Exception as e:
+    if local_path.exists():
+      local_path.unlink()
+    raise RuntimeError(f"Failed to download {asset_name}: {e}") from e
+
+
+def ensure_default_checkpoint() -> str:
+  """Ensure default checkpoint is available and return its absolute path."""
+  checkpoint_path = ensure_asset_downloaded("demo_ckpt.pt")
+  return str(checkpoint_path.resolve())
+
+
+def ensure_default_motion() -> str:
+  """Ensure default motion file is available and return its absolute path."""
+  motion_path = ensure_asset_downloaded("demo_motion.npz")
+  return str(motion_path.resolve())
diff --git a/src/mjlab/scripts/list_envs.py b/src/mjlab/scripts/list_envs.py
new file mode 100644
index 0000000..fae4e94
--- /dev/null
+++ b/src/mjlab/scripts/list_envs.py
@@ -0,0 +1,48 @@
+"""Script to list mjlab environments."""
+
+import tyro
+from prettytable import PrettyTable
+
+import mjlab
+import mjlab.tasks  # noqa: F401
+from mjlab.tasks.registry import list_tasks
+
+
+def list_environments(keyword: str | None = None):
+  """List all registered environments.
+
+  Args:
+    keyword: Optional filter to only show environments containing this keyword.
+  """
+  table = PrettyTable(["#", "Task ID"])
+  table.title = "Available Environments in mjlab"
+  table.align["Task ID"] = "l"
+
+  all_tasks = list_tasks()
+  idx = 0
+  for task_id in all_tasks:
+    try:
+      # Optionally filter by keyword.
+      if keyword and keyword.lower() not in task_id.lower():
+        continue
+
+      table.add_row([idx + 1, task_id])
+      idx += 1
+    except Exception:
+      continue
+
+  print(table)
+  if idx == 0:
+    msg = "[INFO] No tasks matched"
+    if keyword:
+      msg += f" keyword '{keyword}'"
+    print(msg)
+  return idx
+
+
+def main():
+  return tyro.cli(list_environments, config=mjlab.TYRO_FLAGS)
+
+
+if __name__ == "__main__":
+  main()
diff --git a/src/mjlab/scripts/nan_viz.py b/src/mjlab/scripts/nan_viz.py
new file mode 100644
index 0000000..8abe446
--- /dev/null
+++ b/src/mjlab/scripts/nan_viz.py
@@ -0,0 +1,179 @@
+"""Visualize NaN dump states in Viser.
+
+Loads a NaN dump (npz + mjb) and provides a slider to scrub through captured
+states frame by frame.
+
+Example:
+  uv run viz-nan /tmp/mjlab/nan_dumps/nan_dump_20251014_095857.npz
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import mujoco
+import numpy as np
+import tyro
+import viser
+
+import mjlab
+from mjlab.viewer.viser import ViserMujocoScene
+
+
+class NanDumpViewer:
+  """Viewer for NaN dump files."""
+
+  def __init__(self, dump_path: str | Path):
+    self.dump_path = Path(dump_path)
+    self.output_dir = self.dump_path.parent
+
+    print(f"Loading NaN dump from: {self.dump_path}")
+    self.dump = np.load(self.dump_path, allow_pickle=True)
+    self.metadata = self.dump["_metadata"].item()
+
+    model_file = self.output_dir / self.metadata["model_file"]
+    print(f"Loading model from: {model_file}")
+    self.model = mujoco.MjModel.from_binary_path(str(model_file))
+    self.data = mujoco.MjData(self.model)
+
+    self.state_keys = sorted(
+      [k for k in self.dump.keys() if k.startswith("states_step_")],
+      key=lambda x: int(x.split("_")[-1]),
+    )
+    self.state_spec = self.metadata.get(
+      "state_spec", mujoco.mjtState.mjSTATE_PHYSICS.value
+    )
+    self.num_steps = len(self.state_keys)
+    self.num_envs_dumped = self.metadata["num_envs_dumped"]
+    self.dumped_env_ids = self.metadata["dumped_env_ids"]
+
+    print("\nDump info:")
+    print(f"  Total environments: {self.metadata['num_envs_total']}")
+    print(f"  Dumped environments: {self.num_envs_dumped}")
+    print(f"  Dumped env IDs: {self.dumped_env_ids}")
+    print(f"  NaN detected in envs: {self.metadata['nan_env_ids']}")
+    print(f"  Buffer size: {self.num_steps} steps")
+    print(f"  State size: {self.metadata['state_size']}")
+
+    self.server = viser.ViserServer(label="NaN Dump Viewer")
+    self.current_step = 0
+    self.current_env = 0
+    self.scene = ViserMujocoScene(self.server, self.model, num_envs=1)
+
+  def setup(self) -> None:
+    """Setup the viewer GUI and scene."""
+    self.info_html = self.server.gui.add_html(self._get_info_html())
+
+    with self.server.gui.add_folder("Playback"):
+      self.step_slider = self.server.gui.add_slider(
+        "Step",
+        min=0,
+        max=self.num_steps - 1,
+        step=1,
+        initial_value=0,
+        hint=f"Scrub through {self.num_steps} captured states",
+      )
+
+      @self.step_slider.on_update
+      def _(_) -> None:
+        self.current_step = int(self.step_slider.value)
+        self._update_state()
+
+      if self.num_envs_dumped > 1:
+        self.env_slider = self.server.gui.add_slider(
+          "Environment",
+          min=0,
+          max=self.num_envs_dumped - 1,
+          step=1,
+          initial_value=0,
+          hint=f"Select environment (0-{self.num_envs_dumped - 1})",
+        )
+
+        @self.env_slider.on_update
+        def _(_) -> None:
+          self.current_env = int(self.env_slider.value)
+          self._update_state()
+
+    # Add standard visualization options (hide debug viz control since no env).
+    self.scene.create_scene_gui(show_debug_viz_control=False)
+
+    # Initial state update.
+    self._update_state()
+
+  def _get_info_html(self) -> str:
+    """Generate info HTML."""
+    nan_env_ids = self.metadata["nan_env_ids"]
+    nan_env_str = ", ".join(str(e) for e in nan_env_ids[:10])
+    if len(nan_env_ids) > 10:
+      nan_env_str += "..."
+
+    step_name = self.state_keys[self.current_step]
+    step_num = int(step_name.split("_")[-1])
+
+    actual_env_id = self.dumped_env_ids[self.current_env]
+    is_nan_env = actual_env_id in nan_env_ids
+    nan_indicator = "⚠️ NaN Detected" if is_nan_env else "✓ Clean"
+
+    return f"""
+      <div style="font-size: 0.85em; line-height: 1.25; padding: 0 1em 0.5em 1em;">
+        <strong>Step:</strong> {step_num}<br/>
+        <strong>Environment:</strong> {actual_env_id}<br/>
+        <strong>Status:</strong> {nan_indicator}<br/>
+        <strong>NaN envs:</strong> {nan_env_str}
+      </div>
+    """
+
+  def _update_state(self) -> None:
+    """Update the visualization to show the current state."""
+    state_key = self.state_keys[self.current_step]
+    states = self.dump[state_key]
+    state = states[self.current_env]
+
+    # Set state and compute derived quantities.
+    mujoco.mj_setState(self.model, self.data, state, self.state_spec)
+    mujoco.mj_forward(self.model, self.data)
+
+    # Update scene from single-environment MuJoCo data.
+    self.scene.update_from_mjdata(self.data)
+
+    # Update info display.
+    self.info_html.content = self._get_info_html()
+
+  def run(self) -> None:
+    """Run the viewer (blocks until server is stopped)."""
+    print("\nUse the sliders to scrub through states.")
+    print("Press Ctrl+C to exit.")
+
+    try:
+      while True:
+        import time
+
+        # Check if visualization settings changed and need a refresh.
+        if self.scene.needs_update:
+          self.scene.refresh_visualization()
+
+        time.sleep(0.1)
+    except KeyboardInterrupt:
+      print("\nShutting down...")
+      self.server.stop()
+
+
+def run_viewer(dump_path: tyro.conf.Positional[str]):
+  """View NaN dump states in Viser.
+
+  Args:
+    dump_path: Path to nan_dump_TIMESTAMP.npz file.
+  """
+  viewer = NanDumpViewer(dump_path)
+  viewer.setup()
+  viewer.run()
+
+
+def main():
+  """CLI entry point for viz-nan command."""
+
+  tyro.cli(run_viewer, description=__doc__, config=mjlab.TYRO_FLAGS)
+
+
+if __name__ == "__main__":
+  main()
diff --git a/src/mjlab/scripts/play.py b/src/mjlab/scripts/play.py
new file mode 100644
index 0000000..dce4b55
--- /dev/null
+++ b/src/mjlab/scripts/play.py
@@ -0,0 +1,331 @@
+"""Script to play RL agent with RSL-RL."""
+
+import os
+import sys
+import time as _time
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Literal
+
+import torch
+import tyro
+
+from mjlab.envs import ManagerBasedRlEnv
+from mjlab.rl import MjlabOnPolicyRunner, RslRlVecEnvWrapper
+from mjlab.scripts._cli import maybe_print_top_level_help
+from mjlab.tasks.registry import list_tasks, load_env_cfg, load_rl_cfg, load_runner_cls
+from mjlab.tasks.tracking.mdp import MotionCommandCfg
+from mjlab.utils.os import get_wandb_checkpoint_path
+from mjlab.utils.torch import configure_torch_backends
+from mjlab.utils.wrappers import VideoRecorder
+from mjlab.viewer import NativeMujocoViewer, ViserPlayViewer
+from mjlab.viewer.viser.viewer import CheckpointManager, format_time_ago
+
+
+def _parse_wandb_dt(value: str | datetime) -> datetime:
+  """Parse a W&B datetime string (or pass through a datetime object)."""
+  if isinstance(value, str):
+    return datetime.fromisoformat(value.replace("Z", "+00:00"))
+  return value
+
+
+@dataclass(frozen=True)
+class PlayConfig:
+  agent: Literal["zero", "random", "trained"] = "trained"
+  registry_name: str | None = None
+  wandb_run_path: str | None = None
+  wandb_checkpoint_name: str | None = None
+  """Optional checkpoint name within the W&B run to load (e.g. 'model_4000.pt')."""
+  checkpoint_file: str | None = None
+  motion_file: str | None = None
+  num_envs: int | None = None
+  device: str | None = None
+  video: bool = False
+  video_length: int = 200
+  video_height: int | None = None
+  video_width: int | None = None
+  camera: int | str | None = None
+  viewer: Literal["auto", "native", "viser"] = "auto"
+  no_terminations: bool = False
+  """Disable all termination conditions (useful for viewing motions with dummy agents)."""
+  log_root: str = "logs/rsl_rl"
+  """Root directory under which experiment logs are written."""
+
+  # Internal flag used by demo script.
+  _demo_mode: tyro.conf.Suppress[bool] = False
+
+
+def run_play(task_id: str, cfg: PlayConfig):
+  configure_torch_backends()
+
+  device = cfg.device or ("cuda:0" if torch.cuda.is_available() else "cpu")
+
+  env_cfg = load_env_cfg(task_id, play=True)
+  agent_cfg = load_rl_cfg(task_id)
+
+  DUMMY_MODE = cfg.agent in {"zero", "random"}
+  TRAINED_MODE = not DUMMY_MODE
+
+  # Disable terminations if requested (useful for viewing motions).
+  if cfg.no_terminations:
+    env_cfg.terminations = {}
+    print("[INFO]: Terminations disabled")
+
+  # Check if this is a tracking task by checking for motion command.
+  is_tracking_task = "motion" in env_cfg.commands and isinstance(
+    env_cfg.commands["motion"], MotionCommandCfg
+  )
+
+  if is_tracking_task and cfg._demo_mode:
+    # Demo mode: use uniform sampling to see more diversity with num_envs > 1.
+    motion_cmd = env_cfg.commands["motion"]
+    assert isinstance(motion_cmd, MotionCommandCfg)
+    motion_cmd.sampling_mode = "uniform"
+
+  if is_tracking_task:
+    motion_cmd = env_cfg.commands["motion"]
+    assert isinstance(motion_cmd, MotionCommandCfg)
+
+    # Check for local motion file first (works for both dummy and trained modes).
+    if cfg.motion_file is not None and Path(cfg.motion_file).exists():
+      print(f"[INFO]: Using local motion file: {cfg.motion_file}")
+      motion_cmd.motion_file = cfg.motion_file
+    elif DUMMY_MODE:
+      if not cfg.registry_name:
+        raise ValueError(
+          "Tracking tasks require either:\n"
+          "  --motion-file /path/to/motion.npz (local file)\n"
+          "  --registry-name your-org/motions/motion-name (download from WandB)"
+        )
+      # Check if the registry name includes alias, if not, append ":latest".
+      registry_name = cfg.registry_name
+      if ":" not in registry_name:
+        registry_name = registry_name + ":latest"
+      import wandb
+
+      api = wandb.Api()
+      artifact = api.artifact(registry_name)
+      motion_cmd.motion_file = str(Path(artifact.download()) / "motion.npz")
+    else:
+      if cfg.motion_file is not None:
+        print(f"[INFO]: Using motion file from CLI: {cfg.motion_file}")
+        motion_cmd.motion_file = cfg.motion_file
+      else:
+        import wandb
+
+        api = wandb.Api()
+        if cfg.wandb_run_path is None and cfg.checkpoint_file is not None:
+          raise ValueError(
+            "Tracking tasks require `motion_file` when using `checkpoint_file`, "
+            "or provide `wandb_run_path` so the motion artifact can be resolved."
+          )
+        if cfg.wandb_run_path is not None:
+          wandb_run = api.run(str(cfg.wandb_run_path))
+          art = next(
+            (a for a in wandb_run.used_artifacts() if a.type == "motions"), None
+          )
+          if art is None:
+            raise RuntimeError("No motion artifact found in the run.")
+          motion_cmd.motion_file = str(Path(art.download()) / "motion.npz")
+
+  log_dir: Path | None = None
+  resume_path: Path | None = None
+  if TRAINED_MODE:
+    log_root_path = (Path(cfg.log_root) / agent_cfg.experiment_name).resolve()
+    if cfg.checkpoint_file is not None:
+      resume_path = Path(cfg.checkpoint_file)
+      if not resume_path.exists():
+        raise FileNotFoundError(f"Checkpoint file not found: {resume_path}")
+      print(f"[INFO]: Loading checkpoint: {resume_path.name}")
+    else:
+      if cfg.wandb_run_path is None:
+        raise ValueError(
+          "`wandb_run_path` is required when `checkpoint_file` is not provided."
+        )
+      resume_path, was_cached = get_wandb_checkpoint_path(
+        log_root_path, Path(cfg.wandb_run_path), cfg.wandb_checkpoint_name
+      )
+      # Extract run_id and checkpoint name from path for display.
+      run_id = resume_path.parent.name
+      checkpoint_name = resume_path.name
+      cached_str = "cached" if was_cached else "downloaded"
+      print(
+        f"[INFO]: Loading checkpoint: {checkpoint_name} (run: {run_id}, {cached_str})"
+      )
+    log_dir = resume_path.parent
+
+  if cfg.num_envs is not None:
+    env_cfg.scene.num_envs = cfg.num_envs
+  if cfg.video_height is not None:
+    env_cfg.viewer.height = cfg.video_height
+  if cfg.video_width is not None:
+    env_cfg.viewer.width = cfg.video_width
+
+  render_mode = "rgb_array" if (TRAINED_MODE and cfg.video) else None
+  if cfg.video and DUMMY_MODE:
+    print(
+      "[WARN] Video recording with dummy agents is disabled (no checkpoint/log_dir)."
+    )
+  env = ManagerBasedRlEnv(cfg=env_cfg, device=device, render_mode=render_mode)
+
+  if TRAINED_MODE and cfg.video:
+    print("[INFO] Recording videos during play")
+    assert log_dir is not None  # log_dir is set in TRAINED_MODE block
+    env = VideoRecorder(
+      env,
+      video_folder=log_dir / "videos" / "play",
+      step_trigger=lambda step: step == 0,
+      video_length=cfg.video_length,
+      disable_logger=True,
+    )
+
+  env = RslRlVecEnvWrapper(env, clip_actions=agent_cfg.clip_actions)
+  if DUMMY_MODE:
+    action_shape: tuple[int, ...] = env.unwrapped.action_space.shape
+    if cfg.agent == "zero":
+
+      class PolicyZero:
+        def __call__(self, obs) -> torch.Tensor:
+          del obs
+          return torch.zeros(action_shape, device=env.unwrapped.device)
+
+      policy = PolicyZero()
+    else:
+
+      class PolicyRandom:
+        def __call__(self, obs) -> torch.Tensor:
+          del obs
+          return 2 * torch.rand(action_shape, device=env.unwrapped.device) - 1
+
+      policy = PolicyRandom()
+  else:
+    runner_cls = load_runner_cls(task_id) or MjlabOnPolicyRunner
+    runner = runner_cls(env, asdict(agent_cfg), device=device)
+    runner.load(
+      str(resume_path), load_cfg={"actor": True}, strict=True, map_location=device
+    )
+    policy = runner.get_inference_policy(device=device)
+
+  # Build checkpoint manager for hot-swapping checkpoints in the viewer.
+  ckpt_manager: CheckpointManager | None = None
+  if TRAINED_MODE and resume_path is not None:
+    _ckpt_runner = runner  # pyright: ignore[reportPossiblyUnboundVariable]
+
+    def _reload_policy(path: str):
+      _ckpt_runner.load(
+        path,
+        load_cfg={"actor": True},
+        strict=True,
+        map_location=device,
+      )
+      return _ckpt_runner.get_inference_policy(device=device)
+
+    if cfg.wandb_run_path is None:
+      ckpt_dir = resume_path.parent
+
+      def fetch_available_local() -> list[tuple[str, str]]:
+        now = _time.time()
+        entries: list[tuple[str, str, int]] = []
+        for f in sorted(ckpt_dir.glob("*.pt")):
+          try:
+            step = int(f.stem.split("_")[1])
+          except (IndexError, ValueError):
+            step = 0
+          ago = format_time_ago(int(now - f.stat().st_mtime))
+          entries.append((f.name, ago, step))
+        entries.sort(key=lambda x: x[2])
+        return [(name, t) for name, t, _ in entries]
+
+      ckpt_manager = CheckpointManager(
+        current_name=resume_path.name,
+        fetch_available=fetch_available_local,
+        load_checkpoint=lambda name: _reload_policy(str(ckpt_dir / name)),
+      )
+    else:
+      import wandb
+
+      api = wandb.Api()
+      run_path = str(cfg.wandb_run_path)
+      wandb_run = api.run(run_path)
+      _log_root = log_root_path  # pyright: ignore[reportPossiblyUnboundVariable]
+
+      def fetch_available_wandb() -> list[tuple[str, str]]:
+        wandb_run.load()
+        now = datetime.now(tz=timezone.utc)
+        entries: list[tuple[str, str, int]] = []
+        for f in wandb_run.files():
+          if not f.name.endswith(".pt"):
+            continue
+          try:
+            step = int(f.name.split("_")[1].split(".")[0])
+          except (IndexError, ValueError):
+            step = 0
+          ago = format_time_ago(
+            int((now - _parse_wandb_dt(f.updated_at)).total_seconds())
+          )
+          entries.append((f.name, ago, step))
+        entries.sort(key=lambda x: x[2])
+        return [(name, t) for name, t, _ in entries]
+
+      ckpt_manager = CheckpointManager(
+        current_name=resume_path.name,
+        fetch_available=fetch_available_wandb,
+        load_checkpoint=lambda name: _reload_policy(
+          str(get_wandb_checkpoint_path(_log_root, Path(run_path), name)[0])
+        ),
+        run_name=_parse_wandb_dt(wandb_run.created_at).strftime("%Y-%m-%d_%H-%M-%S"),
+        run_url=wandb_run.url,
+        run_status=wandb_run.state,
+      )
+
+  # Handle "auto" viewer selection.
+  if cfg.viewer == "auto":
+    has_display = bool(os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY"))
+    resolved_viewer = "native" if has_display else "viser"
+    del has_display
+  else:
+    resolved_viewer = cfg.viewer
+
+  if resolved_viewer == "native":
+    NativeMujocoViewer(env, policy).run()
+  elif resolved_viewer == "viser":
+    ViserPlayViewer(env, policy, checkpoint_manager=ckpt_manager).run()
+  else:
+    raise RuntimeError(f"Unsupported viewer backend: {resolved_viewer}")
+
+  env.close()
+
+
+def main():
+  maybe_print_top_level_help("play")
+
+  # Parse first argument to choose the task.
+  # Import tasks to populate the registry.
+  import mjlab.tasks  # noqa: F401
+
+  all_tasks = list_tasks()
+  chosen_task, remaining_args = tyro.cli(
+    tyro.extras.literal_type_from_choices(all_tasks),
+    add_help=False,
+    return_unknown_args=True,
+    config=mjlab.TYRO_FLAGS,
+  )
+
+  # Parse the rest of the arguments + allow overriding env_cfg and agent_cfg.
+  agent_cfg = load_rl_cfg(chosen_task)
+
+  args = tyro.cli(
+    PlayConfig,
+    args=remaining_args,
+    default=PlayConfig(),
+    prog=sys.argv[0] + f" {chosen_task}",
+    config=mjlab.TYRO_FLAGS,
+  )
+  del remaining_args, agent_cfg
+
+  run_play(chosen_task, args)
+
+
+if __name__ == "__main__":
+  main()
diff --git a/src/mjlab/scripts/train.py b/src/mjlab/scripts/train.py
new file mode 100644
index 0000000..c27e582
--- /dev/null
+++ b/src/mjlab/scripts/train.py
@@ -0,0 +1,258 @@
+"""Script to train RL agent with RSL-RL."""
+
+import logging
+import os
+import sys
+from dataclasses import asdict, dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Literal, cast
+
+import tyro
+
+from mjlab.envs import ManagerBasedRlEnv, ManagerBasedRlEnvCfg
+from mjlab.rl import MjlabOnPolicyRunner, RslRlBaseRunnerCfg, RslRlVecEnvWrapper
+from mjlab.scripts._cli import maybe_print_top_level_help
+from mjlab.tasks.registry import list_tasks, load_env_cfg, load_rl_cfg, load_runner_cls
+from mjlab.tasks.tracking.mdp import MotionCommandCfg
+from mjlab.utils.gpu import select_gpus
+from mjlab.utils.os import dump_yaml, get_checkpoint_path, get_wandb_checkpoint_path
+from mjlab.utils.torch import configure_torch_backends
+from mjlab.utils.wandb import add_wandb_tags
+from mjlab.utils.wrappers import VideoRecorder
+
+
+@dataclass(frozen=True)
+class TrainConfig:
+  env: ManagerBasedRlEnvCfg
+  agent: RslRlBaseRunnerCfg
+  registry_name: str | None = None
+  video: bool = False
+  video_length: int = 200
+  video_interval: int = 2000
+  enable_nan_guard: bool = False
+  log_root: str = "logs/rsl_rl"
+  """Root directory under which experiment logs are written."""
+  torchrunx_log_dir: str | None = None
+  wandb_run_path: str | None = None
+  wandb_checkpoint_name: str | None = None
+  """Optional checkpoint name within the W&B run to load (e.g. 'model_4000.pt')."""
+  gpu_ids: list[int] | Literal["all"] | None = field(default_factory=lambda: [0])
+
+  @staticmethod
+  def from_task(task_id: str) -> "TrainConfig":
+    env_cfg = load_env_cfg(task_id)
+    agent_cfg = load_rl_cfg(task_id)
+    return TrainConfig(env=env_cfg, agent=agent_cfg)
+
+
+def run_train(task_id: str, cfg: TrainConfig, log_dir: Path) -> None:
+  cuda_visible = os.environ.get("CUDA_VISIBLE_DEVICES", "")
+  if cuda_visible == "":
+    device = "cpu"
+    seed = cfg.agent.seed
+    rank = 0
+  else:
+    local_rank = int(os.environ.get("LOCAL_RANK", "0"))
+    rank = int(os.environ.get("RANK", "0"))
+    # Set EGL device to match the CUDA device.
+    os.environ["MUJOCO_EGL_DEVICE_ID"] = str(local_rank)
+    device = f"cuda:{local_rank}"
+    # Set seed to have diversity in different processes.
+    seed = cfg.agent.seed + rank
+
+  configure_torch_backends()
+
+  cfg.agent.seed = seed
+  cfg.env.seed = seed
+
+  print(f"[INFO] Training with: device={device}, seed={seed}, rank={rank}")
+
+  registry_name: str | None = None
+
+  # Check if this is a tracking task by checking for motion command.
+  is_tracking_task = "motion" in cfg.env.commands and isinstance(
+    cfg.env.commands["motion"], MotionCommandCfg
+  )
+
+  if is_tracking_task:
+    motion_cmd = cfg.env.commands["motion"]
+    assert isinstance(motion_cmd, MotionCommandCfg)
+
+    # Check if motion_file is already set (e.g., via CLI --env.commands.motion.motion-file).
+    if motion_cmd.motion_file and Path(motion_cmd.motion_file).exists():
+      print(f"[INFO] Using local motion file: {motion_cmd.motion_file}")
+    elif cfg.registry_name:
+      # Download from WandB registry.
+      registry_name = cast(str, cfg.registry_name)
+      if ":" not in registry_name:
+        registry_name = registry_name + ":latest"
+      import wandb
+
+      api = wandb.Api()
+      artifact = api.artifact(registry_name)
+      motion_cmd.motion_file = str(Path(artifact.download()) / "motion.npz")
+    else:
+      raise ValueError(
+        "For tracking tasks, provide either:\n"
+        "  --registry-name your-org/motions/motion-name (download from WandB)\n"
+        "  --env.commands.motion.motion-file /path/to/motion.npz (local file)"
+      )
+
+  # Enable NaN guard if requested.
+  if cfg.enable_nan_guard:
+    cfg.env.sim.nan_guard.enabled = True
+    print(f"[INFO] NaN guard enabled, output dir: {cfg.env.sim.nan_guard.output_dir}")
+
+  if rank == 0:
+    print(f"[INFO] Logging experiment in directory: {log_dir}")
+
+  env = ManagerBasedRlEnv(
+    cfg=cfg.env, device=device, render_mode="rgb_array" if cfg.video else None
+  )
+
+  log_root_path = log_dir.parent  # Go up from specific run dir to experiment dir.
+
+  resume_path: Path | None = None
+  if cfg.agent.resume:
+    if cfg.wandb_run_path is not None:
+      # Load checkpoint from W&B.
+      resume_path, was_cached = get_wandb_checkpoint_path(
+        log_root_path, Path(cfg.wandb_run_path), cfg.wandb_checkpoint_name
+      )
+      if rank == 0:
+        run_id = resume_path.parent.name
+        checkpoint_name = resume_path.name
+        cached_str = "cached" if was_cached else "downloaded"
+        print(
+          f"[INFO]: Loading checkpoint from W&B: {checkpoint_name} "
+          f"(run: {run_id}, {cached_str})"
+        )
+    else:
+      # Load checkpoint from local filesystem.
+      resume_path = get_checkpoint_path(
+        log_root_path, cfg.agent.load_run, cfg.agent.load_checkpoint
+      )
+
+  # Only record videos on rank 0 to avoid multiple workers writing to the same files.
+  if cfg.video and rank == 0:
+    env = VideoRecorder(
+      env,
+      video_folder=Path(log_dir) / "videos" / "train",
+      step_trigger=lambda step: step % cfg.video_interval == 0,
+      video_length=cfg.video_length,
+      disable_logger=True,
+    )
+    print("[INFO] Recording videos during training.")
+
+  env = RslRlVecEnvWrapper(env, clip_actions=cfg.agent.clip_actions)
+
+  agent_cfg = asdict(cfg.agent)
+  env_cfg = asdict(cfg.env)
+
+  runner_cls = load_runner_cls(task_id)
+  if runner_cls is None:
+    runner_cls = MjlabOnPolicyRunner
+
+  runner_kwargs = {}
+  if is_tracking_task:
+    runner_kwargs["registry_name"] = registry_name
+
+  # Write config files before runner creation, since the runner mutates agent_cfg
+  # in-place (e.g., injecting non-serializable objects).
+  if rank == 0:
+    dump_yaml(log_dir / "params" / "env.yaml", env_cfg)
+    dump_yaml(log_dir / "params" / "agent.yaml", agent_cfg)
+
+  runner = runner_cls(env, agent_cfg, str(log_dir), device, **runner_kwargs)
+
+  add_wandb_tags(cfg.agent.wandb_tags)
+  runner.add_git_repo_to_log(__file__)
+  if resume_path is not None:
+    print(f"[INFO]: Loading model checkpoint from: {resume_path}")
+    runner.load(str(resume_path))
+
+  runner.learn(
+    num_learning_iterations=cfg.agent.max_iterations, init_at_random_ep_len=True
+  )
+
+  env.close()
+
+
+def launch_training(task_id: str, args: TrainConfig | None = None):
+  args = args or TrainConfig.from_task(task_id)
+
+  # Create log directory once before launching workers.
+  log_root_path = (Path(args.log_root) / args.agent.experiment_name).resolve()
+  log_dir_name = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+  if args.agent.run_name:
+    log_dir_name += f"_{args.agent.run_name}"
+  log_dir = log_root_path / log_dir_name
+
+  # Select GPUs based on CUDA_VISIBLE_DEVICES and user specification.
+  selected_gpus, num_gpus = select_gpus(args.gpu_ids)
+
+  # Set environment variables for all modes.
+  if selected_gpus is None:
+    os.environ["CUDA_VISIBLE_DEVICES"] = ""
+  else:
+    os.environ["CUDA_VISIBLE_DEVICES"] = ",".join(map(str, selected_gpus))
+
+  if num_gpus <= 1:
+    # CPU or single GPU: run directly without torchrunx.
+    run_train(task_id, args, log_dir)
+  else:
+    # Multi-GPU: use torchrunx.
+    import torchrunx
+
+    # torchrunx redirects stdout to logging.
+    logging.basicConfig(level=logging.INFO)
+
+    # Configure torchrunx logging directory.
+    # Priority: 1) existing env var, 2) user flag, 3) default to {log_dir}/torchrunx.
+    if "TORCHRUNX_LOG_DIR" not in os.environ:
+      if args.torchrunx_log_dir is not None:
+        # User specified a value via flag (could be "" to disable).
+        os.environ["TORCHRUNX_LOG_DIR"] = args.torchrunx_log_dir
+      else:
+        # Default: put logs in training directory.
+        os.environ["TORCHRUNX_LOG_DIR"] = str(log_dir / "torchrunx")
+
+    print(f"[INFO] Launching training with {num_gpus} GPUs", flush=True)
+    torchrunx.Launcher(
+      hostnames=["localhost"],
+      workers_per_host=num_gpus,
+      backend=None,  # Let rsl_rl handle process group initialization.
+      copy_env_vars=torchrunx.DEFAULT_ENV_VARS_FOR_COPY + ("MUJOCO*",),
+    ).run(run_train, task_id, args, log_dir)
+
+
+def main():
+  maybe_print_top_level_help("train")
+
+  # Parse first argument to choose the task.
+  # Import tasks to populate the registry.
+  import mjlab.tasks  # noqa: F401
+
+  all_tasks = list_tasks()
+  chosen_task, remaining_args = tyro.cli(
+    tyro.extras.literal_type_from_choices(all_tasks),
+    add_help=False,
+    return_unknown_args=True,
+    config=mjlab.TYRO_FLAGS,
+  )
+
+  args = tyro.cli(
+    TrainConfig,
+    args=remaining_args,
+    default=TrainConfig.from_task(chosen_task),
+    prog=sys.argv[0] + f" {chosen_task}",
+    config=mjlab.TYRO_FLAGS,
+  )
+  del remaining_args
+
+  launch_training(task_id=chosen_task, args=args)
+
+
+if __name__ == "__main__":
+  main()
diff --git a/src/mjlab/scripts/visualize_terrain.py b/src/mjlab/scripts/visualize_terrain.py
new file mode 100644
index 0000000..764d968
--- /dev/null
+++ b/src/mjlab/scripts/visualize_terrain.py
@@ -0,0 +1,535 @@
+"""Interactive terrain visualizer using Viser.
+
+Displays a 10-row grid of terrains with increasing difficulty.
+Configurations and parameters are dynamically loaded from mjlab.terrains.config.
+
+Run with:
+  uv run src/mjlab/scripts/visualize_terrain.py
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import re
+import time
+from typing import Any, List, TypedDict
+
+import mujoco
+import numpy as np
+import trimesh
+import viser
+from mjviser.conversions import (
+  create_primitive_mesh,
+  merge_geoms,
+  mujoco_mesh_to_trimesh,
+)
+from mujoco import mjtGeom
+
+from mjlab.asset_zoo.robots import (
+  get_g1_robot_cfg,
+  get_go1_robot_cfg,
+  get_yam_robot_cfg,
+)
+from mjlab.terrains.config import ALL_TERRAINS_CFG
+from mjlab.terrains.terrain_generator import (
+  TerrainGenerator,
+  TerrainGeneratorCfg,
+)
+
+# Supported robots for visualization.
+ROBOT_CFG_GETTERS = {
+  "None": None,
+  "Unitree Go1": get_go1_robot_cfg,
+  "Unitree G1": get_g1_robot_cfg,
+  "Yam": get_yam_robot_cfg,
+}
+
+# Parameter range hints for sliders.
+PARAM_HINTS = {
+  "octaves": (1, 10, 1),
+  "persistence": (0.0, 1.0, 0.05),
+  "lacunarity": (1.0, 5.0, 0.1),
+  "scale": (0.01, 0.5, 0.01),
+  "horizontal_scale": (0.001, 0.1, 0.001),
+  "resolution": (0.1, 2.0, 0.1),
+  "base_thickness_ratio": (0.1, 2.0, 0.1),
+  "border_width": (0.0, 2.0, 0.05),
+  "amplitude_range": (0.0, 1.0, 0.05),
+  "height_range": (0.0, 2.0, 0.05),
+  "num_waves": (1, 20, 1),
+  "num_obstacles": (1, 100, 1),
+  "obstacle_height_range": (0.0, 1.0, 0.05),
+  "obstacle_width_range": (0.1, 2.0, 0.05),
+  "box_width_range": (0.1, 2.0, 0.05),
+  "box_length_range": (0.1, 2.0, 0.05),
+  "slope_range": (0.0, 1.0, 0.05),
+  "platform_width": (0.1, 5.0, 0.1),
+  "step_height_range": (0.0, 0.5, 0.01),
+  "step_width": (0.1, 1.0, 0.05),
+  "grid_width": (0.1, 1.0, 0.05),
+  "grid_height_range": (0.0, 1.0, 0.05),
+  "height_merge_threshold": (0.01, 0.2, 0.01),
+  "max_merge_distance": (1, 10, 1),
+  "num_beams": (1, 64, 1),
+  "num_rings": (1, 32, 1),
+  "displacement_range": (0.0, 1.0, 0.005),
+  "stone_size_variation": (0.0, 1.0, 0.005),
+  "stone_height_variation": (0.0, 1.0, 0.005),
+}
+
+
+class _AppState(TypedDict):
+  preset_name: str
+  robot_name: str
+  seed: int
+  size: tuple[float, float]
+  params: dict[str, Any]
+  rows: int
+  cols: int
+  difficulty_range: tuple[float, float]
+  robot_handles: list[Any]
+  terrain_origins: np.ndarray | None
+
+
+def main():
+  server = viser.ViserServer()
+
+  # Load available terrains from config.
+  available_presets = ALL_TERRAINS_CFG.sub_terrains
+  preset_names = ["All Terrains"] + list(available_presets.keys())
+
+  # State management.
+  state: _AppState = {
+    "preset_name": preset_names[0],
+    "robot_name": "None",
+    "seed": 42,
+    "size": ALL_TERRAINS_CFG.size,
+    "params": {},
+    "rows": 10,
+    "cols": 1,
+    "difficulty_range": (0.0, 1.0),
+    "robot_handles": [],
+    "terrain_origins": None,
+  }
+
+  # Handle for the terrain mesh in the scene.
+  terrain_handle: viser.SceneNodeHandle | None = None
+
+  # GUI for statistics.
+  gui_stats_folder = server.gui.add_folder("Statistics")
+  with gui_stats_folder:
+    status_label = server.gui.add_markdown("**Status:** Ready")
+    polygon_count_label = server.gui.add_markdown("**Number of Polygons:** -")
+
+  def update_robots():
+    # Clear old robot handles.
+    for h in state["robot_handles"]:
+      h.remove()
+    state["robot_handles"] = []
+
+    if state["robot_name"] == "None" or state["terrain_origins"] is None:
+      status_label.content = "**Status:** Ready"
+      return
+
+    status_label.content = f"**Status:** Spawning {state['robot_name']}..."
+
+    # Get robot config.
+    robot_cfg_getter = ROBOT_CFG_GETTERS[state["robot_name"]]
+    if robot_cfg_getter is None:
+      return
+    robot_cfg = robot_cfg_getter()
+
+    # Merge robot template mesh.
+    # We compile the robot spec standalone to get a clean local-space mesh template.
+    robot_spec = robot_cfg.spec_fn()
+    if robot_spec.worldbody.bodies:
+      robot_spec.worldbody.bodies[0].pos = (0, 0, 0)
+
+    if robot_spec.keys:
+      robot_spec.delete(robot_spec.keys[0])
+
+    robot_model = robot_spec.compile()
+    robot_data = mujoco.MjData(robot_model)
+
+    # Apply joint poses.
+    joint_pos = robot_cfg.init_state.joint_pos
+    if joint_pos is None:
+      joint_pos = {}
+    for pattern, val in joint_pos.items():
+      if not pattern.startswith("^"):
+        pattern = ".*" + pattern
+      for j_id in range(robot_model.njnt):
+        name = mujoco.mj_id2name(robot_model, mujoco.mjtObj.mjOBJ_JOINT, j_id)
+        if re.match(pattern, name):
+          adr = robot_model.jnt_qposadr[j_id]
+          robot_data.qpos[adr] = val
+
+    mujoco.mj_forward(robot_model, robot_data)
+
+    # Filter for visual geoms only (group < 3).
+    visual_geom_ids = [
+      i for i in range(robot_model.ngeom) if robot_model.geom_group[i] < 3
+    ]
+    if not visual_geom_ids:
+      status_label.content = "**Status:** Error: No visual geoms for robot"
+      print(f"Error: No visual geoms found for {state['robot_name']}")
+      return
+
+    # Merge visual geoms in world space.
+    meshes = []
+    for gid in visual_geom_ids:
+      if robot_model.geom_type[gid] == mjtGeom.mjGEOM_MESH:
+        mesh = mujoco_mesh_to_trimesh(robot_model, gid)
+      else:
+        mesh = create_primitive_mesh(robot_model, gid)
+      xform = np.eye(4)
+      xform[:3, :3] = robot_data.geom_xmat[gid].reshape(3, 3)
+      xform[:3, 3] = robot_data.geom_xpos[gid]
+      mesh.apply_transform(xform)
+      meshes.append(mesh)
+    robot_mesh = trimesh.util.concatenate(meshes) if len(meshes) > 1 else meshes[0]
+    n_verts = len(robot_mesh.vertices)
+    n_faces = len(robot_mesh.faces)
+    print(f"Robot mesh: {n_verts} vertices, {n_faces} faces.")
+
+    # Prepare batched positions.
+    num_rows, num_cols = state["terrain_origins"].shape[:2]
+    batched_positions = []
+    for row in range(num_rows):
+      for col in range(num_cols):
+        origin = state["terrain_origins"][row, col]
+        pos = origin + np.array(robot_cfg.init_state.pos)
+        batched_positions.append(pos)
+
+    batched_positions = np.array(batched_positions)
+    n = len(batched_positions)
+    print(f"Instancing {n} robots at positions like {batched_positions[0]}")
+    batched_wxyzs = np.array([1.0, 0.0, 0.0, 0.0])[None].repeat(
+      len(batched_positions), axis=0
+    )
+
+    with server.atomic():
+      handle = server.scene.add_batched_meshes_trimesh(
+        "/robots_batched",
+        robot_mesh,
+        batched_positions=batched_positions,
+        batched_wxyzs=batched_wxyzs,
+      )
+      state["robot_handles"].append(handle)
+    status_label.content = "**Status:** Ready"
+
+  def update_terrain():
+    nonlocal terrain_handle
+    status_label.content = "**Status:** Generating terrain..."
+
+    if state["preset_name"] == "All Terrains":
+      # Create a copy with equal proportions to ensure all are shown once.
+      sub_terrains = {}
+      for name, cfg in available_presets.items():
+        new_cfg = dataclasses.replace(cfg, proportion=1.0)
+        sub_terrains[name] = new_cfg
+      num_cols = len(sub_terrains)
+      num_rows = state["rows"]
+    else:
+      selected_instance = available_presets[state["preset_name"]]
+      terrain_type = type(selected_instance)
+
+      # Instantiate sub-terrain config with current GUI state.
+      sub_cfg_params = {}
+      for field in dataclasses.fields(terrain_type):
+        if field.name in ["proportion", "size", "flat_patch_sampling"]:
+          sub_cfg_params[field.name] = getattr(selected_instance, field.name)
+          continue
+
+        if "range" in field.name and isinstance(
+          getattr(selected_instance, field.name), (tuple, list)
+        ):
+          if field.name + "_min" in state["params"]:
+            sub_cfg_params[field.name] = (
+              state["params"][field.name + "_min"],
+              state["params"][field.name + "_max"],
+            )
+          else:
+            sub_cfg_params[field.name] = getattr(selected_instance, field.name)
+        elif field.name in state["params"]:
+          sub_cfg_params[field.name] = state["params"][field.name]
+        else:
+          sub_cfg_params[field.name] = getattr(selected_instance, field.name)
+
+      try:
+        sub_cfg = terrain_type(**sub_cfg_params)
+      except Exception as e:
+        print(f"Error creating config: {e}")
+        return
+
+      num_rows = state["rows"]
+      num_cols = state["cols"]
+      sub_terrains = {state["preset_name"]: sub_cfg}
+
+    generator_cfg = TerrainGeneratorCfg(
+      seed=state["seed"],
+      size=state["size"],
+      num_rows=num_rows,
+      num_cols=num_cols,
+      curriculum=True,
+      difficulty_range=state["difficulty_range"],
+      sub_terrains=sub_terrains,
+      add_lights=True,
+    )
+
+    generator = TerrainGenerator(generator_cfg)
+    spec = mujoco.MjSpec()
+    generator.compile(spec)
+
+    # Save terrain metadata for robot spawning.
+    state["terrain_origins"] = generator.terrain_origins
+
+    status_label.content = "**Status:** Compiling MuJoCo model..."
+    model = spec.compile()
+    data = mujoco.MjData(model)
+
+    mujoco.mj_forward(model, data)
+
+    # Find terrain geoms.
+    terrain_body_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_BODY, "terrain")
+    terrain_geom_ids = [
+      i for i in range(model.ngeom) if model.geom_bodyid[i] == terrain_body_id
+    ]
+
+    if not terrain_geom_ids:
+      status_label.content = "**Status:** Error: No terrain geoms found"
+      print("No terrain geoms found.")
+      return
+
+    status_label.content = (
+      f"**Status:** Merging {len(terrain_geom_ids)} terrain geoms..."
+    )
+    terrain_mesh = merge_geoms(model, terrain_geom_ids)
+    num_faces = len(terrain_mesh.faces)
+    polygon_count_label.content = f"**Number of Polygons:** {num_faces:,}"
+
+    # Remove old terrain mesh if exists.
+    if terrain_handle is not None:
+      terrain_handle.remove()
+
+    status_label.content = "**Status:** Uploading terrain mesh..."
+    terrain_handle = server.scene.add_mesh_trimesh(
+      "/terrain",
+      terrain_mesh,
+    )
+
+    # Trigger robot update.
+    update_robots()
+
+  # GUI Setup.
+  gui_params_folder = server.gui.add_folder("Terrain Parameters")
+  param_controls: List[Any] = []
+
+  def rebuild_gui():
+    nonlocal param_controls
+    for control in param_controls:
+      control.remove()
+    param_controls.clear()
+
+    if state["preset_name"] == "All Terrains":
+      with gui_params_folder:
+        md = server.gui.add_markdown(
+          "_Parameters not available for 'All Terrains' mode._"
+        )
+        param_controls.append(md)
+      return
+
+    selected_instance = available_presets[state["preset_name"]]
+    terrain_type = type(selected_instance)
+    fields = dataclasses.fields(terrain_type)
+
+    with gui_params_folder:
+      for field in fields:
+        if field.name in ["proportion", "size", "flat_patch_sampling"]:
+          continue
+
+        # Get type as string for comparison (handles future annotations).
+        type_str = str(field.type)
+
+        # Check for range tuples first.
+        if "range" in field.name and isinstance(
+          getattr(selected_instance, field.name), (tuple, list)
+        ):
+          hint = PARAM_HINTS.get(field.name, (0.0, 1.0, 0.01))
+
+          val_min, val_max = getattr(selected_instance, field.name)
+
+          # Store in state if not present.
+          if field.name + "_min" not in state["params"]:
+            state["params"][field.name + "_min"] = val_min
+            state["params"][field.name + "_max"] = val_max
+
+          cur_min = state["params"][field.name + "_min"]
+          cur_max = state["params"][field.name + "_max"]
+
+          v_min, v_max, v_step = hint
+          # Ensure range is valid for sliders.
+          if cur_min is not None:
+            v_min = min(v_min, cur_min)
+          else:
+            cur_min = v_min
+
+          if cur_max is not None:
+            v_max = max(v_max, cur_max)
+          else:
+            cur_max = v_max
+
+          s_min = server.gui.add_slider(
+            f"{field.name} min",
+            min=v_min,
+            max=v_max,
+            step=v_step,
+            initial_value=cur_min,
+          )
+          s_max = server.gui.add_slider(
+            f"{field.name} max",
+            min=v_min,
+            max=v_max,
+            step=v_step,
+            initial_value=cur_max,
+          )
+
+          @s_min.on_update
+          def _(event, name=field.name):
+            state["params"][name + "_min"] = event.target.value
+            update_terrain()
+
+          @s_max.on_update
+          def _(event, name=field.name):
+            state["params"][name + "_max"] = event.target.value
+            update_terrain()
+
+          param_controls.extend([s_min, s_max])
+
+        elif "float" in type_str or "int" in type_str or field.type in [float, int]:
+          hint = PARAM_HINTS.get(field.name, (0.0, 10.0, 0.1))
+          val = getattr(selected_instance, field.name)
+
+          if field.name not in state["params"]:
+            state["params"][field.name] = val
+
+          cur_val = state["params"][field.name]
+          v_min, v_max, v_step = hint
+          if cur_val is not None:
+            v_min = min(v_min, cur_val)
+            v_max = max(v_max, cur_val)
+          else:
+            cur_val = (v_min + v_max) / 2.0
+
+          slider = server.gui.add_slider(
+            field.name, min=v_min, max=v_max, step=v_step, initial_value=cur_val
+          )
+
+          @slider.on_update
+          def _(
+            event, name=field.name, is_int=("int" in type_str) or field.type is int
+          ):
+            val = event.target.value
+            if is_int:
+              val = int(val)
+            state["params"][name] = val
+            update_terrain()
+
+          param_controls.append(slider)
+
+        elif "bool" in type_str or field.type is bool:
+          val = getattr(selected_instance, field.name)
+          if field.name not in state["params"]:
+            state["params"][field.name] = val
+
+          checkbox = server.gui.add_checkbox(
+            field.name, initial_value=state["params"][field.name]
+          )
+
+          @checkbox.on_update
+          def _(event, name=field.name):
+            state["params"][name] = event.target.value
+            update_terrain()
+
+          param_controls.append(checkbox)
+        else:
+          # Fallback for other simple types if they have a default value.
+          try:
+            val = getattr(selected_instance, field.name)
+            if isinstance(val, (int, float)):
+              if field.name not in state["params"]:
+                state["params"][field.name] = val
+              slider = server.gui.add_slider(
+                field.name,
+                min=min(0.0, val),
+                max=max(10.0, val),
+                step=0.1,
+                initial_value=val,
+              )
+
+              @slider.on_update
+              def _(event, name=field.name):
+                state["params"][name] = event.target.value
+                update_terrain()
+
+              param_controls.append(slider)
+          except Exception:
+            pass
+
+  # Global Controls.
+  with server.gui.add_folder("Global Settings"):
+    preset_select = server.gui.add_dropdown(
+      "Preset", options=preset_names, initial_value=state["preset_name"]
+    )
+
+    @preset_select.on_update
+    def _(event):
+      state["preset_name"] = event.target.value
+      state["params"] = {}  # Clear local overrides for new preset.
+      rebuild_gui()
+      update_terrain()
+
+    seed_input = server.gui.add_number("Seed", initial_value=int(state["seed"]))
+
+    @seed_input.on_update
+    def _(event):
+      state["seed"] = int(event.target.value)
+      update_terrain()
+
+    robot_select = server.gui.add_dropdown(
+      "Robot", options=list(ROBOT_CFG_GETTERS.keys()), initial_value=state["robot_name"]
+    )
+
+    @robot_select.on_update
+    def _(event):
+      state["robot_name"] = event.target.value
+      update_robots()
+
+    btn_randomize = server.gui.add_button("Randomize Seed")
+
+    @btn_randomize.on_click
+    def _(_):
+      new_seed = np.random.randint(0, 10000)
+      seed_input.value = new_seed
+      state["seed"] = int(new_seed)
+      update_terrain()
+
+    btn_reset_camera = server.gui.add_button("Reset Camera")
+
+    @btn_reset_camera.on_click
+    def _(_):
+      for client in server.get_clients().values():
+        client.camera.position = (10, 10, 10)
+        client.camera.look_at = (0, 0, 0)
+
+  # Initialize.
+  rebuild_gui()
+  update_terrain()
+
+  print("Viser Terrain Visualizer running...")
+  while True:
+    time.sleep(1.0)
+
+
+if __name__ == "__main__":
+  main()
diff --git a/src/mjlab/sensor/__init__.py b/src/mjlab/sensor/__init__.py
new file mode 100644
index 0000000..06ef5c4
--- /dev/null
+++ b/src/mjlab/sensor/__init__.py
@@ -0,0 +1,28 @@
+from mjlab.sensor.builtin_sensor import BuiltinSensor as BuiltinSensor
+from mjlab.sensor.builtin_sensor import BuiltinSensorCfg as BuiltinSensorCfg
+from mjlab.sensor.builtin_sensor import ObjRef as ObjRef
+from mjlab.sensor.camera_sensor import CameraSensor as CameraSensor
+from mjlab.sensor.camera_sensor import CameraSensorCfg as CameraSensorCfg
+from mjlab.sensor.camera_sensor import CameraSensorData as CameraSensorData
+from mjlab.sensor.contact_sensor import ContactData as ContactData
+from mjlab.sensor.contact_sensor import ContactMatch as ContactMatch
+from mjlab.sensor.contact_sensor import ContactSensor as ContactSensor
+from mjlab.sensor.contact_sensor import ContactSensorCfg as ContactSensorCfg
+from mjlab.sensor.raycast_sensor import GridPatternCfg as GridPatternCfg
+from mjlab.sensor.raycast_sensor import (
+  PinholeCameraPatternCfg as PinholeCameraPatternCfg,
+)
+from mjlab.sensor.raycast_sensor import RayCastData as RayCastData
+from mjlab.sensor.raycast_sensor import RayCastSensor as RayCastSensor
+from mjlab.sensor.raycast_sensor import RayCastSensorCfg as RayCastSensorCfg
+from mjlab.sensor.raycast_sensor import RingPatternCfg as RingPatternCfg
+from mjlab.sensor.sensor import Sensor as Sensor
+from mjlab.sensor.sensor import SensorCfg as SensorCfg
+from mjlab.sensor.sensor_context import SensorContext as SensorContext
+from mjlab.sensor.terrain_height_sensor import TerrainHeightData as TerrainHeightData
+from mjlab.sensor.terrain_height_sensor import (
+  TerrainHeightSensor as TerrainHeightSensor,
+)
+from mjlab.sensor.terrain_height_sensor import (
+  TerrainHeightSensorCfg as TerrainHeightSensorCfg,
+)
diff --git a/src/mjlab/sensor/builtin_sensor.py b/src/mjlab/sensor/builtin_sensor.py
new file mode 100644
index 0000000..81d7856
--- /dev/null
+++ b/src/mjlab/sensor/builtin_sensor.py
@@ -0,0 +1,346 @@
+"""Sensors that wrap MuJoCo builtin sensors."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+import mujoco
+import mujoco_warp as mjwarp
+import torch
+
+from mjlab.entity import Entity
+from mjlab.sensor.sensor import Sensor, SensorCfg
+
+SensorType = Literal[
+  # Site sensors.
+  "accelerometer",
+  "velocimeter",
+  "gyro",
+  "force",
+  "torque",
+  "magnetometer",
+  "rangefinder",
+  # Joint sensors.
+  "jointpos",
+  "jointvel",
+  "jointlimitpos",
+  "jointlimitvel",
+  "jointlimitfrc",
+  "jointactuatorfrc",
+  # Tendon sensors.
+  "tendonpos",
+  "tendonvel",
+  "tendonactuatorfrc",
+  # Actuator sensors.
+  "actuatorpos",
+  "actuatorvel",
+  "actuatorfrc",
+  # Frame sensors.
+  "framepos",
+  "framequat",
+  "framexaxis",
+  "frameyaxis",
+  "framezaxis",
+  "framelinvel",
+  "frameangvel",
+  "framelinacc",
+  "frameangacc",
+  # Subtree sensors.
+  "subtreecom",
+  "subtreelinvel",
+  "subtreeangmom",
+  # Misc.
+  "e_potential",
+  "e_kinetic",
+  "clock",
+]
+
+_SENSOR_TYPE_MAP = {
+  # Site sensors.
+  "accelerometer": mujoco.mjtSensor.mjSENS_ACCELEROMETER,
+  "velocimeter": mujoco.mjtSensor.mjSENS_VELOCIMETER,
+  "gyro": mujoco.mjtSensor.mjSENS_GYRO,
+  "force": mujoco.mjtSensor.mjSENS_FORCE,
+  "torque": mujoco.mjtSensor.mjSENS_TORQUE,
+  "magnetometer": mujoco.mjtSensor.mjSENS_MAGNETOMETER,
+  "rangefinder": mujoco.mjtSensor.mjSENS_RANGEFINDER,
+  # Joint sensors.
+  "jointpos": mujoco.mjtSensor.mjSENS_JOINTPOS,
+  "jointvel": mujoco.mjtSensor.mjSENS_JOINTVEL,
+  "jointlimitpos": mujoco.mjtSensor.mjSENS_JOINTLIMITPOS,
+  "jointlimitvel": mujoco.mjtSensor.mjSENS_JOINTLIMITVEL,
+  "jointlimitfrc": mujoco.mjtSensor.mjSENS_JOINTLIMITFRC,
+  "jointactuatorfrc": mujoco.mjtSensor.mjSENS_JOINTACTFRC,
+  # Tendon sensors.
+  "tendonpos": mujoco.mjtSensor.mjSENS_TENDONPOS,
+  "tendonvel": mujoco.mjtSensor.mjSENS_TENDONVEL,
+  "tendonactuatorfrc": mujoco.mjtSensor.mjSENS_TENDONACTFRC,
+  # Actuator sensors.
+  "actuatorpos": mujoco.mjtSensor.mjSENS_ACTUATORPOS,
+  "actuatorvel": mujoco.mjtSensor.mjSENS_ACTUATORVEL,
+  "actuatorfrc": mujoco.mjtSensor.mjSENS_ACTUATORFRC,
+  # Frame sensors.
+  "framepos": mujoco.mjtSensor.mjSENS_FRAMEPOS,
+  "framequat": mujoco.mjtSensor.mjSENS_FRAMEQUAT,
+  "framexaxis": mujoco.mjtSensor.mjSENS_FRAMEXAXIS,
+  "frameyaxis": mujoco.mjtSensor.mjSENS_FRAMEYAXIS,
+  "framezaxis": mujoco.mjtSensor.mjSENS_FRAMEZAXIS,
+  "framelinvel": mujoco.mjtSensor.mjSENS_FRAMELINVEL,
+  "frameangvel": mujoco.mjtSensor.mjSENS_FRAMEANGVEL,
+  "framelinacc": mujoco.mjtSensor.mjSENS_FRAMELINACC,
+  "frameangacc": mujoco.mjtSensor.mjSENS_FRAMEANGACC,
+  # Subtree sensors.
+  "subtreecom": mujoco.mjtSensor.mjSENS_SUBTREECOM,
+  "subtreelinvel": mujoco.mjtSensor.mjSENS_SUBTREELINVEL,
+  "subtreeangmom": mujoco.mjtSensor.mjSENS_SUBTREEANGMOM,
+  # Misc.
+  "clock": mujoco.mjtSensor.mjSENS_CLOCK,
+  "e_potential": mujoco.mjtSensor.mjSENS_E_POTENTIAL,
+  "e_kinetic": mujoco.mjtSensor.mjSENS_E_KINETIC,
+}
+
+_OBJECT_TYPE_MAP = {
+  "body": mujoco.mjtObj.mjOBJ_BODY,
+  "xbody": mujoco.mjtObj.mjOBJ_XBODY,
+  "joint": mujoco.mjtObj.mjOBJ_JOINT,
+  "geom": mujoco.mjtObj.mjOBJ_GEOM,
+  "site": mujoco.mjtObj.mjOBJ_SITE,
+  "actuator": mujoco.mjtObj.mjOBJ_ACTUATOR,
+  "tendon": mujoco.mjtObj.mjOBJ_TENDON,
+  "camera": mujoco.mjtObj.mjOBJ_CAMERA,
+}
+
+_SENSORS_REQUIRING_SITE = {
+  "accelerometer",
+  "velocimeter",
+  "gyro",
+  "force",
+  "torque",
+  "magnetometer",
+  "rangefinder",
+}
+
+_SENSORS_REQUIRING_SPATIAL_FRAME = {
+  "framepos",
+  "framequat",
+  "framexaxis",
+  "frameyaxis",
+  "framezaxis",
+  "framelinvel",
+  "frameangvel",
+  "framelinacc",
+  "frameangacc",
+}
+
+_SENSORS_REQUIRING_BODY = {
+  "subtreecom",
+  "subtreelinvel",
+  "subtreeangmom",
+}
+
+_SENSOR_OBJECT_REQUIREMENTS = {
+  "jointpos": "joint",
+  "jointvel": "joint",
+  "jointlimitpos": "joint",
+  "jointlimitvel": "joint",
+  "jointlimitfrc": "joint",
+  "jointactuatorfrc": "joint",
+  "tendonpos": "tendon",
+  "tendonvel": "tendon",
+  "tendonactuatorfrc": "tendon",
+  "actuatorpos": "actuator",
+  "actuatorvel": "actuator",
+  "actuatorfrc": "actuator",
+}
+
+_SPATIAL_FRAME_TYPES = {"body", "xbody", "geom", "site", "camera"}
+_SENSORS_ALLOWING_REF = {
+  "framepos",
+  "framequat",
+  "framexaxis",
+  "frameyaxis",
+  "framezaxis",
+  "framelinvel",
+  "frameangvel",
+  "framelinacc",
+  "frameangacc",
+}
+
+
+@dataclass
+class ObjRef:
+  """Reference to a MuJoCo object (body, joint, site, etc.).
+
+  Used to specify which object a sensor is attached to and its frame of reference.
+  The entity field allows scoping objects to specific entity namespaces.
+  """
+
+  type: Literal[
+    "body", "xbody", "joint", "geom", "site", "actuator", "tendon", "camera"
+  ]
+  """Type of the object."""
+  name: str
+  """Name of the object."""
+  entity: str | None = None
+  """Optional entity prefix for the object name."""
+
+  def prefixed_name(self) -> str:
+    """Get the full name with entity prefix if applicable."""
+    if self.entity:
+      return f"{self.entity}/{self.name}"
+    return self.name
+
+
+@dataclass
+class BuiltinSensorCfg(SensorCfg):
+  sensor_type: SensorType
+  """Which builtin sensor to use."""
+  obj: ObjRef | None = None
+  """The type and name of the object the sensor is attached to."""
+  ref: ObjRef | None = None
+  """The type and name of object to which the frame-of-reference is attached to."""
+  cutoff: float = 0.0
+  """When this value is positive, it limits the absolute value of the sensor output."""
+
+  @property
+  def prefixed_name(self) -> str:
+    """The sensor name with entity prefix if applicable."""
+    if self.obj is not None and self.obj.entity is not None:
+      return f"{self.obj.entity}/{self.name}"
+    return self.name
+
+  def __post_init__(self) -> None:
+    if self.sensor_type in _SENSORS_REQUIRING_SITE:
+      if self.obj is None:
+        raise ValueError(
+          f"Sensor type '{self.sensor_type}' requires obj with type='site'"
+        )
+      if self.obj.type != "site":
+        raise ValueError(
+          f"Sensor type '{self.sensor_type}' requires obj.type='site', got "
+          f"'{self.obj.type}'"
+        )
+
+    elif self.sensor_type in _SENSORS_REQUIRING_SPATIAL_FRAME:
+      if self.obj is None:
+        raise ValueError(
+          f"Sensor type '{self.sensor_type}' requires obj with spatial frame"
+        )
+      if self.obj.type not in _SPATIAL_FRAME_TYPES:
+        raise ValueError(
+          f"Sensor type '{self.sensor_type}' requires obj.type in "
+          f"{_SPATIAL_FRAME_TYPES}, got '{self.obj.type}'"
+        )
+
+    elif self.sensor_type in _SENSORS_REQUIRING_BODY:
+      if self.obj is None:
+        raise ValueError(
+          f"Sensor type '{self.sensor_type}' requires obj with type='body'"
+        )
+      if self.obj.type != "body":
+        raise ValueError(
+          f"Sensor type '{self.sensor_type}' requires obj.type='body', "
+          f"got '{self.obj.type}'"
+        )
+
+    elif self.sensor_type in _SENSOR_OBJECT_REQUIREMENTS:
+      required_type = _SENSOR_OBJECT_REQUIREMENTS[self.sensor_type]
+      if self.obj is None:
+        raise ValueError(
+          f"Sensor type '{self.sensor_type}' requires obj with type='{required_type}'"
+        )
+      if self.obj.type != required_type:
+        raise ValueError(
+          f"Sensor type '{self.sensor_type}' requires obj.type='{required_type}', "
+          f"got '{self.obj.type}'"
+        )
+
+    if self.ref is not None and self.sensor_type not in _SENSORS_ALLOWING_REF:
+      raise ValueError(
+        f"Sensor type '{self.sensor_type}' does not support ref specification"
+      )
+
+  def build(self) -> BuiltinSensor:
+    return BuiltinSensor(self)
+
+
+class BuiltinSensor(Sensor[torch.Tensor]):
+  """Wrapper over MuJoCo builtin sensors.
+
+  Can add a new sensor to the spec, or wrap an existing sensor from entity XML.
+  Returns raw MuJoCo sensordata as torch.Tensor with shape depending on sensor type
+  (e.g., accelerometer: (N, 3), framequat: (N, 4)).
+
+  Note: Caching provides minimal benefit here since data access is just a tensor
+  slice view into MuJoCo's sensordata buffer.
+  """
+
+  def __init__(
+    self, cfg: BuiltinSensorCfg | None = None, name: str | None = None
+  ) -> None:
+    super().__init__()
+    if cfg is not None:
+      self._name = cfg.prefixed_name
+      self.cfg: BuiltinSensorCfg | None = cfg
+    else:
+      assert name is not None, "Must provide either cfg or name"
+      self._name = name
+      self.cfg = None
+    self._data: mjwarp.Data | None = None
+    self._data_view: torch.Tensor | None = None
+
+  @classmethod
+  def from_existing(cls, name: str) -> BuiltinSensor:
+    """Wrap an existing sensor already defined in entity XML."""
+    return cls(cfg=None, name=name)
+
+  def edit_spec(self, scene_spec: mujoco.MjSpec, entities: dict[str, Entity]) -> None:
+    del entities
+    if self.cfg is None:
+      return
+
+    # Check for duplicate sensors.
+    for sensor in scene_spec.sensors:
+      if sensor.name == self.cfg.prefixed_name:
+        is_entity_scoped = self.cfg.obj is not None and self.cfg.obj.entity is not None
+        if is_entity_scoped:
+          raise ValueError(
+            f"Sensor '{self.cfg.prefixed_name}' is defined in both entity XML and "
+            f"scene config. Remove the sensor definition from the entity XML file, "
+            f"or remove the BuiltinSensorCfg from scene.sensors."
+          )
+        else:
+          raise ValueError(
+            f"Sensor '{self.cfg.prefixed_name}' already exists in the scene. "
+            f"Rename this sensor to avoid conflicts."
+          )
+
+    # Add sensor to spec.
+    scene_spec.add_sensor(
+      name=self.cfg.prefixed_name,
+      type=_SENSOR_TYPE_MAP[self.cfg.sensor_type],
+      objtype=(
+        _OBJECT_TYPE_MAP[self.cfg.obj.type] if self.cfg.obj is not None else None
+      ),
+      objname=(self.cfg.obj.prefixed_name() if self.cfg.obj is not None else None),
+      reftype=(
+        _OBJECT_TYPE_MAP[self.cfg.ref.type] if self.cfg.ref is not None else None
+      ),
+      refname=(self.cfg.ref.prefixed_name() if self.cfg.ref is not None else None),
+      cutoff=self.cfg.cutoff if self.cfg.cutoff > 0 else None,
+    )
+
+  def initialize(
+    self, mj_model: mujoco.MjModel, model: mjwarp.Model, data: mjwarp.Data, device: str
+  ) -> None:
+    del model, device
+    self._data = data
+    sensor = mj_model.sensor(self._name)
+    start = sensor.adr[0]
+    dim = sensor.dim[0]
+    self._data_view = self._data.sensordata[:, start : start + dim]
+
+  def _compute_data(self) -> torch.Tensor:
+    assert self._data_view is not None
+    return self._data_view
diff --git a/src/mjlab/sensor/camera_sensor.py b/src/mjlab/sensor/camera_sensor.py
new file mode 100644
index 0000000..93b9f35
--- /dev/null
+++ b/src/mjlab/sensor/camera_sensor.py
@@ -0,0 +1,230 @@
+"""Camera sensor for RGB, depth, and segmentation rendering."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal
+
+import mujoco
+import mujoco_warp as mjwarp
+import torch
+
+from mjlab.entity import Entity
+from mjlab.sensor.sensor import Sensor, SensorCfg
+
+if TYPE_CHECKING:
+  from mjlab.sensor.sensor_context import SensorContext
+
+CameraDataType = Literal["rgb", "depth", "segmentation"]
+
+# Default MuJoCo fov, in degrees.
+_DEFAULT_CAM_FOVY = 45.0
+
+
+@dataclass
+class CameraSensorCfg(SensorCfg):
+  """Configuration for a camera sensor.
+
+  A camera sensor can either wrap an existing MuJoCo camera
+  (``camera_name``) or create a new one at the specified
+  pos/quat. New cameras are added to the worldbody by default,
+  or to a specific body via ``parent_body``.
+
+  Note:
+    All camera sensors in a scene must share identical values for
+    use_textures, use_shadows, and enabled_geom_groups. This is a
+    constraint of the underlying mujoco_warp rendering system.
+  """
+
+  camera_name: str | None = None
+  """Name of an existing MuJoCo camera to wrap.
+
+  If None, a new camera is created using pos/quat/fovy.
+  If set, the sensor wraps the named camera instead of creating one.
+  """
+
+  parent_body: str | None = None
+  """Parent body to attach a new camera to.
+
+  Only used when ``camera_name`` is None (creating a new camera).
+  If None, the camera is added to the worldbody. Use the full
+  prefixed name (e.g., "robot/link_6") to attach to an entity's
+  body. The pos/quat are then relative to the parent body frame.
+  """
+
+  pos: tuple[float, float, float] = (0.0, 0.0, 1.0)
+  """Camera position (used when creating a new camera).
+
+  World-frame if parent_body is None, otherwise relative to the
+  parent body frame.
+  """
+
+  quat: tuple[float, float, float, float] = (1.0, 0.0, 0.0, 0.0)
+  """Camera orientation quaternion (w, x, y, z)."""
+
+  fovy: float | None = None
+  """Vertical field of view in degrees. None uses MuJoCo default."""
+
+  width: int = 160
+  """Image width in pixels."""
+
+  height: int = 120
+  """Image height in pixels."""
+
+  data_types: tuple[CameraDataType, ...] = ("rgb",)
+  """Data types to capture: any combination of "rgb", "depth",
+  and "segmentation"."""
+
+  use_textures: bool = True
+  """Whether to use textures in rendering."""
+
+  use_shadows: bool = False
+  """Whether to use shadows in rendering."""
+
+  enabled_geom_groups: tuple[int, ...] = (0, 1, 2)
+  """Geom groups (0-5) visible to the camera."""
+
+  orthographic: bool = False
+  """Use orthographic projection instead of perspective."""
+
+  clone_data: bool = False
+  """If True, clone tensors on each access.
+
+  Set to True if you modify the returned data in-place.
+  """
+
+  def __post_init__(self) -> None:
+    valid = {"rgb", "depth", "segmentation"}
+    invalid = {dt for dt in self.data_types if dt not in valid}
+    if invalid:
+      raise ValueError(f"Invalid camera data types: {invalid}. Valid types: {valid}")
+    if not self.data_types:
+      raise ValueError("At least one data type must be specified.")
+
+  def build(self) -> CameraSensor:
+    return CameraSensor(self)
+
+
+@dataclass
+class CameraSensorData:
+  """Camera sensor output data.
+
+  Shapes:
+    - rgb: [num_envs, height, width, 3] (uint8)
+    - depth: [num_envs, height, width, 1] (float32)
+    - segmentation: [num_envs, height, width, 2] (int32)
+  """
+
+  rgb: torch.Tensor | None = None
+  """RGB image [num_envs, height, width, 3] (uint8). None if not
+  enabled."""
+
+  depth: torch.Tensor | None = None
+  """Depth image [num_envs, height, width, 1] (float32). None if not
+  enabled."""
+
+  segmentation: torch.Tensor | None = None
+  """Per-pixel typed segmentation [num_envs, height, width, 2] (int32).
+
+  Channel 0 stores MuJoCo object IDs. Channel 1 stores the corresponding
+  MuJoCo object types. Background pixels are ``(-1, -1)``.
+  """
+
+
+class CameraSensor(Sensor[CameraSensorData]):
+  """Camera sensor for RGB and depth rendering."""
+
+  requires_sensor_context = True
+
+  def __init__(self, cfg: CameraSensorCfg) -> None:
+    super().__init__()
+    self.cfg = cfg
+    self._camera_name = cfg.camera_name if cfg.camera_name is not None else cfg.name
+    self._is_wrapping_existing = cfg.camera_name is not None
+    self._ctx: SensorContext | None = None
+    self._camera_idx: int = -1
+
+  @property
+  def camera_name(self) -> str:
+    return self._camera_name
+
+  @property
+  def camera_idx(self) -> int:
+    return self._camera_idx
+
+  def edit_spec(
+    self,
+    scene_spec: mujoco.MjSpec,
+    entities: dict[str, Entity],
+  ) -> None:
+    del entities
+
+    if self._is_wrapping_existing:
+      cam = scene_spec.camera(self._camera_name)
+      assert isinstance(cam, mujoco.MjsCamera)
+      if self.cfg.fovy is not None:
+        cam.fovy = self.cfg.fovy
+      if self.cfg.orthographic:
+        cam.proj = mujoco.mjtProjection.mjPROJ_ORTHOGRAPHIC
+      return
+
+    if self.cfg.parent_body is not None:
+      parent = scene_spec.body(self.cfg.parent_body)
+    else:
+      parent = scene_spec.worldbody
+
+    proj = (
+      mujoco.mjtProjection.mjPROJ_ORTHOGRAPHIC
+      if self.cfg.orthographic
+      else mujoco.mjtProjection.mjPROJ_PERSPECTIVE
+    )
+    parent.add_camera(
+      name=self.cfg.name,
+      pos=self.cfg.pos,
+      quat=self.cfg.quat,
+      fovy=self.cfg.fovy if self.cfg.fovy is not None else _DEFAULT_CAM_FOVY,
+      resolution=[self.cfg.width, self.cfg.height],
+      proj=proj,
+    )
+
+  def initialize(
+    self,
+    mj_model: mujoco.MjModel,
+    model: mjwarp.Model,
+    data: mjwarp.Data,
+    device: str,
+  ) -> None:
+    del model, data, device
+
+    try:
+      cam = mj_model.camera(self._camera_name)
+      self._camera_idx = cam.id
+    except KeyError as e:
+      available = [mj_model.camera(i).name for i in range(mj_model.ncam)]
+      raise ValueError(
+        f"Camera '{self._camera_name}' not found in model. Available: {available}"
+      ) from e
+
+  def set_context(self, ctx: SensorContext) -> None:
+    self._ctx = ctx
+
+  def _compute_data(self) -> CameraSensorData:
+    if self._ctx is None:
+      raise RuntimeError(
+        "CameraSensor requires a SensorContext. "
+        "Ensure the sensor is part of a scene with "
+        "sim.sense() calls."
+      )
+    rgb_data = None
+    depth_data = None
+    seg_data = None
+    if "rgb" in self.cfg.data_types:
+      rgb = self._ctx.get_rgb(self._camera_idx)
+      rgb_data = rgb.clone() if self.cfg.clone_data else rgb
+    if "depth" in self.cfg.data_types:
+      depth = self._ctx.get_depth(self._camera_idx)
+      depth_data = depth.clone() if self.cfg.clone_data else depth
+    if "segmentation" in self.cfg.data_types:
+      seg = self._ctx.get_segmentation(self._camera_idx)
+      seg_data = seg.clone() if self.cfg.clone_data else seg
+    return CameraSensorData(rgb=rgb_data, depth=depth_data, segmentation=seg_data)
diff --git a/src/mjlab/sensor/contact_sensor.py b/src/mjlab/sensor/contact_sensor.py
new file mode 100644
index 0000000..80ff0ac
--- /dev/null
+++ b/src/mjlab/sensor/contact_sensor.py
@@ -0,0 +1,671 @@
+"""Contact sensors track collisions between geoms, bodies, or subtrees.
+
+A ``ContactSensor`` resolves regex patterns into a set of *primary* MuJoCo
+elements and (optionally) a single *secondary* element to filter against. Each
+physics step it pulls per-primary contact data from MuJoCo's native contact
+sensor and packages it into a batched ``ContactData`` dataclass.
+
+Shape conventions on ``ContactData``:
+
+- ``P`` = number of primary elements resolved from the pattern (see
+  :attr:`ContactSensor.primary_names` for the index→name mapping).
+- ``N`` = ``P * num_slots`` (per-contact axis, primary-major layout).
+- Per-contact fields (``found``, ``force``, ``torque``, ``dist``, ``pos``,
+  ``normal``, ``tangent``) have shape ``[B, N, ...]``.
+- Per-primary fields (``current_air_time`` etc.) have shape ``[B, P]``.
+
+Most users want the default ``num_slots=1``, in which case ``N == P`` and the
+two shape families coincide.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any, Literal
+
+import mujoco
+import mujoco_warp as mjwarp
+import torch
+
+from mjlab.entity import Entity
+from mjlab.sensor.sensor import Sensor, SensorCfg
+
+_CONTACT_DATA_MAP = {
+  "found": 0,
+  "force": 1,
+  "torque": 2,
+  "dist": 3,
+  "pos": 4,
+  "normal": 5,
+  "tangent": 6,
+}
+
+_CONTACT_DATA_DIMS = {
+  "found": 1,
+  "force": 3,
+  "torque": 3,
+  "dist": 1,
+  "pos": 3,
+  "normal": 3,
+  "tangent": 3,
+}
+
+_CONTACT_REDUCE_MAP = {
+  "none": 0,
+  "mindist": 1,
+  "maxforce": 2,
+  "netforce": 3,
+}
+
+_MODE_TO_OBJTYPE = {
+  "geom": mujoco.mjtObj.mjOBJ_GEOM,
+  "body": mujoco.mjtObj.mjOBJ_BODY,
+  "subtree": mujoco.mjtObj.mjOBJ_XBODY,
+}
+
+
+@dataclass
+class ContactMatch:
+  """Specifies what to match on one side of a contact.
+
+  Args:
+    mode: MuJoCo element type to match against ("geom", "body", or "subtree").
+    pattern: A regex (or tuple of regexes) matched against element names within
+      ``entity``. If ``entity`` is unset, the pattern is treated as a literal
+      MuJoCo name (no regex expansion).
+    entity: Entity name to scope the pattern to. If ``None``/``""``, the
+      pattern is taken as a literal MuJoCo name.
+    exclude: Names to filter out of the match. Each entry is treated as a
+      regex if it contains any regex metacharacters, otherwise as an exact
+      name.
+  """
+
+  mode: Literal["geom", "body", "subtree"]
+  pattern: str | tuple[str, ...]
+  entity: str | None = None
+  exclude: tuple[str, ...] = ()
+
+
+@dataclass
+class ContactSensorCfg(SensorCfg):
+  """Configuration for a :class:`ContactSensor`.
+
+  A contact sensor watches contacts between a ``primary`` set of elements and
+  an optional ``secondary`` element. Patterns expand to multiple primaries
+  (e.g. all four feet on a quadruped); each primary becomes one column on the
+  per-contact axis of the output tensors.
+
+  See the module docstring for shape conventions (``P``, ``N``, primary-major
+  layout) and :attr:`ContactSensor.primary_names` for index→name lookup.
+
+  Args:
+    primary: Elements to measure (e.g. the robot's feet). Typically a regex
+      that resolves to multiple elements.
+    secondary: Optional filter on what the primary may contact (e.g. terrain).
+      ``None`` means "any contact with a primary counts".
+    fields: Which contact quantities to extract. Only requested fields are
+      allocated and computed; the rest are ``None`` on ``ContactData``.
+
+      - ``"found"``: 0 = no contact; >0 = number of matched contacts.
+      - ``"force"``, ``"torque"``: 3D vectors in the contact frame (or in the
+        global frame when ``reduce="netforce"`` or ``global_frame=True``).
+      - ``"dist"``: penetration depth (scalar).
+      - ``"pos"``, ``"normal"``, ``"tangent"``: 3D vectors in the global
+        frame (normal points primary → secondary).
+
+    reduce: How to collapse simultaneous contacts on the same primary down to
+      ``num_slots`` representative contacts.
+
+      - ``"none"``: fast, non-deterministic ordering.
+      - ``"mindist"``: keep the closest (deepest) contacts.
+      - ``"maxforce"``: keep the strongest contacts.
+      - ``"netforce"``: sum all contacts into a single net wrench (always
+        produces one slot per primary regardless of ``num_slots``).
+
+    num_slots: Number of contacts to retain per primary after reduction.
+      Almost always ``1``: most policies want one representative contact per
+      primary, and pattern expansion already gives you many primaries. Only
+      raise this when a single primary may have multiple distinct contacts
+      you want to inspect separately, paired with ``reduce`` in
+      ``{"none", "mindist", "maxforce"}``. Ignored by ``reduce="netforce"``.
+    secondary_policy: How to handle a secondary pattern that resolves to
+      multiple elements: ``"first"`` picks the first match, ``"any"`` drops
+      the secondary filter entirely, ``"error"`` raises.
+    track_air_time: Allocate per-primary air/contact time accumulators
+      (useful for gait rewards). Requires ``"found"`` in ``fields``. Slot
+      reduction within a primary uses an "any slot in contact" rule.
+    global_frame: Rotate ``force``/``torque`` from the contact frame to the
+      global frame. Requires ``"normal"`` and ``"tangent"`` in ``fields``.
+      Implicit when ``reduce="netforce"``.
+    history_length: If >0, keep a rolling buffer of the last N substeps of
+      ``force``/``torque``/``dist`` data. Set to your decimation value so the
+      buffer covers exactly one policy step; useful for catching brief
+      collisions that resolve mid-substep. ``0`` disables the buffer.
+    debug: Print each MuJoCo sensor as it is added to the spec. Useful for
+      checking that pattern expansion produced the elements you expected.
+  """
+
+  primary: ContactMatch
+  secondary: ContactMatch | None = None
+  fields: tuple[str, ...] = ("found", "force")
+  reduce: Literal["none", "mindist", "maxforce", "netforce"] = "maxforce"
+  num_slots: int = 1
+  secondary_policy: Literal["first", "any", "error"] = "first"
+  track_air_time: bool = False
+  global_frame: bool = False
+  history_length: int = 0
+  debug: bool = False
+
+  def build(self) -> ContactSensor:
+    return ContactSensor(self)
+
+
+@dataclass
+class _ContactSlot:
+  """Maps one MuJoCo sensor (one primary, one field) to its sensordata view."""
+
+  primary_name: str
+  field_name: str
+  sensor_name: str
+  data_view: torch.Tensor | None = None
+
+
+@dataclass
+class _AirTimeState:
+  """Tracks how long contacts have been in air/contact. Shape: [B, P]."""
+
+  current_air_time: torch.Tensor
+  last_air_time: torch.Tensor
+  current_contact_time: torch.Tensor
+  last_contact_time: torch.Tensor
+
+
+@dataclass
+class ContactData:
+  """Contact sensor output (only requested fields are populated).
+
+  Shape conventions: P = number of primaries; N = P * num_slots (per-contact
+  fields are laid out primary-major). Air-time fields are per-primary and
+  reduce across slots (any slot in contact → primary in contact).
+  """
+
+  found: torch.Tensor | None = None
+  """[B, N] 0=no contact, >0=match count"""
+  force: torch.Tensor | None = None
+  """[B, N, 3] contact frame (global if reduce="netforce" or global_frame=True)"""
+  torque: torch.Tensor | None = None
+  """[B, N, 3] contact frame (global if reduce="netforce" or global_frame=True)"""
+  dist: torch.Tensor | None = None
+  """[B, N] penetration depth"""
+  pos: torch.Tensor | None = None
+  """[B, N, 3] global frame"""
+  normal: torch.Tensor | None = None
+  """[B, N, 3] global frame, primary→secondary"""
+  tangent: torch.Tensor | None = None
+  """[B, N, 3] global frame"""
+
+  current_air_time: torch.Tensor | None = None
+  """[B, P] time in air per primary (if track_air_time=True)"""
+  last_air_time: torch.Tensor | None = None
+  """[B, P] duration of last air phase per primary (if track_air_time=True)"""
+  current_contact_time: torch.Tensor | None = None
+  """[B, P] time in contact per primary (if track_air_time=True)"""
+  last_contact_time: torch.Tensor | None = None
+  """[B, P] duration of last contact phase per primary (if track_air_time=True)"""
+
+  force_history: torch.Tensor | None = None
+  """[B, N, H, 3] contact forces over last H substeps (index 0 = most recent)"""
+  torque_history: torch.Tensor | None = None
+  """[B, N, H, 3] contact torques over last H substeps (index 0 = most recent)"""
+  dist_history: torch.Tensor | None = None
+  """[B, N, H] penetration depth over last H substeps (index 0 = most recent)"""
+
+
+class ContactSensor(Sensor[ContactData]):
+  """Tracks contacts with automatic pattern expansion to multiple MuJoCo sensors."""
+
+  def __init__(self, cfg: ContactSensorCfg) -> None:
+    super().__init__()
+    self.cfg = cfg
+
+    if cfg.global_frame and cfg.reduce != "netforce":
+      if "normal" not in cfg.fields or "tangent" not in cfg.fields:
+        raise ValueError(
+          f"Sensor '{cfg.name}': global_frame=True requires 'normal' and 'tangent' "
+          "in fields (needed to build rotation matrix)"
+        )
+
+    self._slots: list[_ContactSlot] = []
+    self._data: mjwarp.Data | None = None
+    self._device: str | None = None
+    self._air_time_state: _AirTimeState | None = None
+    self._history_state: dict[str, torch.Tensor] | None = None
+
+  @property
+  def primary_names(self) -> list[str]:
+    """Primary names in the order they appear along the per-contact dim.
+
+    Per-contact fields ([B, N, ...]) are laid out primary-major, so primary
+    `primary_names[i]` occupies indices [i * num_slots : (i + 1) * num_slots].
+    Per-primary fields ([B, P, ...]) have one entry per name in this list.
+    """
+    return list(dict.fromkeys(slot.primary_name for slot in self._slots))
+
+  def edit_spec(self, scene_spec: mujoco.MjSpec, entities: dict[str, Entity]) -> None:
+    """Expand patterns and add MuJoCo sensors (one per primary x field pair)."""
+    self._slots.clear()
+
+    primary_names = self._resolve_primary_names(entities, self.cfg.primary)
+    if self.cfg.secondary is None or self.cfg.secondary_policy == "any":
+      secondary_name = None
+    else:
+      secondary_name = self._resolve_single_secondary(
+        entities, self.cfg.secondary, self.cfg.secondary_policy
+      )
+
+    # MuJoCo allows packing multiple fields into one contact sensor via the
+    # `dataspec` bitfield, but we register one sensor per (primary, field) pair
+    # so each sensor's `sensordata` block is laid out as `[B, num_slots * dim]`
+    # and `_extract_sensor_data` can reshape per field without computing
+    # per-field offsets within an interleaved per-slot layout.
+    for prim in primary_names:
+      for field in self.cfg.fields:
+        sensor_name = f"{self.cfg.name}_{prim}_{field}"
+
+        self._add_contact_sensor_to_spec(
+          scene_spec, sensor_name, prim, secondary_name, field
+        )
+
+        self._slots.append(
+          _ContactSlot(
+            primary_name=prim,
+            field_name=field,
+            sensor_name=sensor_name,
+          )
+        )
+
+  def initialize(
+    self, mj_model: mujoco.MjModel, model: mjwarp.Model, data: mjwarp.Data, device: str
+  ) -> None:
+    """Map sensors to sensordata buffer and allocate air time state."""
+    del model
+
+    if not self._slots:
+      raise RuntimeError(
+        f"There was an error initializing contact sensor '{self.cfg.name}'"
+      )
+
+    for slot in self._slots:
+      sensor = mj_model.sensor(slot.sensor_name)
+      start = sensor.adr[0]
+      dim = sensor.dim[0]
+      slot.data_view = data.sensordata[:, start : start + dim]
+
+    self._data = data
+    self._device = device
+
+    n_primary = len(self.primary_names)
+
+    if self.cfg.track_air_time:
+      n_envs = data.time.shape[0]
+      self._air_time_state = _AirTimeState(
+        current_air_time=torch.zeros((n_envs, n_primary), device=device),
+        last_air_time=torch.zeros((n_envs, n_primary), device=device),
+        current_contact_time=torch.zeros((n_envs, n_primary), device=device),
+        last_contact_time=torch.zeros((n_envs, n_primary), device=device),
+      )
+
+    if self.cfg.history_length > 0:
+      n_envs = data.time.shape[0]
+      n_contacts = n_primary * self.cfg.num_slots
+      h = self.cfg.history_length
+      self._history_state = {}
+      if "force" in self.cfg.fields:
+        self._history_state["force"] = torch.zeros(
+          (n_envs, n_contacts, h, 3), device=device
+        )
+      if "torque" in self.cfg.fields:
+        self._history_state["torque"] = torch.zeros(
+          (n_envs, n_contacts, h, 3), device=device
+        )
+      if "dist" in self.cfg.fields:
+        self._history_state["dist"] = torch.zeros(
+          (n_envs, n_contacts, h), device=device
+        )
+
+  def _compute_data(self) -> ContactData:
+    out = self._extract_sensor_data()
+    if self._air_time_state is not None:
+      out.current_air_time = self._air_time_state.current_air_time
+      out.last_air_time = self._air_time_state.last_air_time
+      out.current_contact_time = self._air_time_state.current_contact_time
+      out.last_contact_time = self._air_time_state.last_contact_time
+    if self._history_state is not None:
+      out.force_history = self._history_state.get("force")
+      out.torque_history = self._history_state.get("torque")
+      out.dist_history = self._history_state.get("dist")
+    return out
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    super().reset(env_ids)
+    if env_ids is None:
+      env_ids = slice(None)
+
+    # Reset air time state for specified envs.
+    if self._air_time_state is not None:
+      self._air_time_state.current_air_time[env_ids] = 0.0
+      self._air_time_state.last_air_time[env_ids] = 0.0
+      self._air_time_state.current_contact_time[env_ids] = 0.0
+      self._air_time_state.last_contact_time[env_ids] = 0.0
+
+    # Reset history state for specified envs.
+    if self._history_state is not None:
+      for buf in self._history_state.values():
+        buf[env_ids] = 0.0
+
+  def update(self, dt: float) -> None:
+    super().update(dt)
+    if self._air_time_state is not None:
+      self._update_air_time_tracking(dt)
+    if self._history_state is not None:
+      self._update_history()
+
+  def compute_first_contact(self, dt: float, abs_tol: float = 1.0e-6) -> torch.Tensor:
+    """Returns [B, P] bool: True for primaries that landed within the last dt seconds."""
+    if self._air_time_state is None:
+      raise RuntimeError(
+        f"Sensor '{self.cfg.name}' must have track_air_time=True "
+        "to use compute_first_contact"
+      )
+    is_in_contact = self._air_time_state.current_contact_time > 0.0
+    within_dt = self._air_time_state.current_contact_time < (dt + abs_tol)
+    return is_in_contact & within_dt
+
+  def compute_first_air(self, dt: float, abs_tol: float = 1.0e-6) -> torch.Tensor:
+    """Returns [B, P] bool: True for primaries that took off within the last dt seconds."""
+    if self._air_time_state is None:
+      raise RuntimeError(
+        f"Sensor '{self.cfg.name}' must have track_air_time=True "
+        "to use compute_first_air"
+      )
+    is_in_air = self._air_time_state.current_air_time > 0.0
+    within_dt = self._air_time_state.current_air_time < (dt + abs_tol)
+    return is_in_air & within_dt
+
+  def _extract_sensor_data(self) -> ContactData:
+    if not self._slots:
+      raise RuntimeError(f"Sensor '{self.cfg.name}' not initialized")
+
+    field_chunks: dict[str, list[torch.Tensor]] = {f: [] for f in self.cfg.fields}
+
+    for slot in self._slots:
+      assert slot.data_view is not None
+      field_dim = _CONTACT_DATA_DIMS[slot.field_name]
+      raw = slot.data_view.view(slot.data_view.size(0), self.cfg.num_slots, field_dim)
+      field_chunks[slot.field_name].append(raw)
+
+    out = ContactData()
+    for field, chunks in field_chunks.items():
+      cat = torch.cat(chunks, dim=1)
+      if cat.size(-1) == 1:
+        cat = cat.squeeze(-1)
+      setattr(out, field, cat)
+
+    if self.cfg.global_frame and self.cfg.reduce != "netforce":
+      out = self._transform_to_global_frame(out)
+
+    return out
+
+  def _transform_to_global_frame(self, data: ContactData) -> ContactData:
+    """Rotate force/torque from contact frame to global frame."""
+    assert data.normal is not None and data.tangent is not None
+
+    normal = data.normal
+    tangent = data.tangent
+    tangent2 = torch.cross(normal, tangent, dim=-1)
+    R = torch.stack([normal, tangent, tangent2], dim=-1)
+
+    has_contact = torch.norm(normal, dim=-1, keepdim=True) > 1e-8
+
+    if data.force is not None:
+      force_global = torch.einsum("...ij,...j->...i", R, data.force)
+      data.force = torch.where(has_contact, force_global, data.force)
+
+    if data.torque is not None:
+      torque_global = torch.einsum("...ij,...j->...i", R, data.torque)
+      data.torque = torch.where(has_contact, torque_global, data.torque)
+
+    return data
+
+  def _update_air_time_tracking(self, dt: float) -> None:
+    assert self._air_time_state is not None
+
+    contact_data = self._extract_sensor_data()
+    if contact_data.found is None or "found" not in self.cfg.fields:
+      return
+
+    # Accumulate the exact float64 substep dt rather than differencing the
+    # float32 sim clock (`data.time`). The clock's quantization error grows with
+    # its magnitude (ULP ~= time * 1.2e-7) and, since `data.time` is never reset
+    # on env reset, it eventually swamps the abs_tol in compute_first_contact.
+    elapsed_time = dt
+
+    # Reduce `found` from [B, P*num_slots] to [B, P]: a primary is in contact
+    # if any of its slots reports a match. Air-time is tracked per primary.
+    found = contact_data.found
+    if self.cfg.num_slots > 1:
+      found = found.view(found.size(0), -1, self.cfg.num_slots).any(dim=-1)
+    is_contact = found > 0
+
+    state = self._air_time_state
+    is_first_contact = (state.current_air_time > 0) & is_contact
+    is_first_detached = (state.current_contact_time > 0) & ~is_contact
+
+    state.last_air_time[:] = torch.where(
+      is_first_contact,
+      state.current_air_time + elapsed_time,
+      state.last_air_time,
+    )
+    state.current_air_time[:] = torch.where(
+      ~is_contact,
+      state.current_air_time + elapsed_time,
+      torch.zeros_like(state.current_air_time),
+    )
+
+    state.last_contact_time[:] = torch.where(
+      is_first_detached,
+      state.current_contact_time + elapsed_time,
+      state.last_contact_time,
+    )
+    state.current_contact_time[:] = torch.where(
+      is_contact,
+      state.current_contact_time + elapsed_time,
+      torch.zeros_like(state.current_contact_time),
+    )
+
+  def _update_history(self) -> None:
+    """Roll history buffer and insert current contact data at index 0."""
+    assert self._history_state is not None
+
+    contact_data = self._extract_sensor_data()
+
+    if "force" in self._history_state and contact_data.force is not None:
+      self._history_state["force"] = self._history_state["force"].roll(1, dims=2)
+      self._history_state["force"][:, :, 0, :] = contact_data.force
+
+    if "torque" in self._history_state and contact_data.torque is not None:
+      self._history_state["torque"] = self._history_state["torque"].roll(1, dims=2)
+      self._history_state["torque"][:, :, 0, :] = contact_data.torque
+
+    if "dist" in self._history_state and contact_data.dist is not None:
+      self._history_state["dist"] = self._history_state["dist"].roll(1, dims=2)
+      self._history_state["dist"][:, :, 0] = contact_data.dist
+
+  def _resolve_primary_names(
+    self, entities: dict[str, Entity], match: ContactMatch
+  ) -> list[str]:
+    if match.entity in (None, ""):
+      result = (
+        [match.pattern] if isinstance(match.pattern, str) else list(match.pattern)
+      )
+      return result
+
+    if match.entity not in entities:
+      raise ValueError(
+        f"Primary entity '{match.entity}' not found. Available: {list(entities.keys())}"
+      )
+    ent = entities[match.entity]
+
+    patterns = [match.pattern] if isinstance(match.pattern, str) else match.pattern
+
+    if match.mode == "geom":
+      _, names = ent.find_geoms(patterns)
+    elif match.mode == "body":
+      _, names = ent.find_bodies(patterns)
+    elif match.mode == "subtree":
+      _, names = ent.find_bodies(patterns)
+      if not names:
+        raise ValueError(
+          f"Primary subtree pattern '{match.pattern}' matched no bodies in "
+          f"'{match.entity}'"
+        )
+    else:
+      raise ValueError("Primary mode must be one of {'geom','body','subtree'}")
+
+    excludes = match.exclude
+    if excludes:
+      exclude_patterns = []
+      exclude_exact = set()
+      for exc in excludes:
+        if any(c in exc for c in r".*+?[]{}()\|^$"):
+          exclude_patterns.append(re.compile(exc))
+        else:
+          exclude_exact.add(exc)
+      if exclude_exact:
+        names = [n for n in names if n not in exclude_exact]
+      if exclude_patterns:
+        names = [n for n in names if not any(rx.search(n) for rx in exclude_patterns)]
+
+    if not names:
+      raise ValueError(
+        f"Primary pattern '{match.pattern}' (after excludes) matched "
+        f"no names in '{match.entity}'"
+      )
+    return names
+
+  def _resolve_single_secondary(
+    self,
+    entities: dict[str, Entity],
+    match: ContactMatch,
+    policy: Literal["first", "any", "error"],
+  ) -> str | None:
+    if policy == "any":
+      return None
+
+    if isinstance(match.pattern, tuple):
+      raise ValueError(
+        "Secondary must specify a single name (string). "
+        "Use a single exact name or a regex that resolves to one name, "
+        "or set secondary_policy='any' if you want no filter."
+      )
+
+    if match.entity in (None, ""):
+      if match.mode not in {"geom", "body", "subtree"}:
+        raise ValueError("Secondary mode must be one of {'geom','body','subtree'}")
+      return match.pattern
+
+    if match.entity not in entities:
+      raise ValueError(
+        f"Secondary entity '{match.entity}' not found. "
+        f"Available: {list(entities.keys())}"
+      )
+    ent = entities[match.entity]
+
+    if match.mode == "subtree":
+      return match.pattern
+
+    if match.mode == "geom":
+      _, names = ent.find_geoms(match.pattern)
+    elif match.mode == "body":
+      _, names = ent.find_bodies(match.pattern)
+    else:
+      raise ValueError("Secondary mode must be one of {'geom','body','subtree'}")
+
+    if not names:
+      raise ValueError(
+        f"Secondary pattern '{match.pattern}' matched nothing in '{match.entity}'"
+      )
+
+    if len(names) == 1 or policy == "first":
+      return names[0]
+
+    raise ValueError(
+      f"Secondary pattern '{match.pattern}' matched multiple: {names}. "
+      f"Be explicit or set secondary_policy='first' or 'any'."
+    )
+
+  def _add_contact_sensor_to_spec(
+    self,
+    scene_spec: mujoco.MjSpec,
+    sensor_name: str,
+    primary_name: str,
+    secondary_name: str | None,
+    field: str,
+  ) -> None:
+    data_bits = 1 << _CONTACT_DATA_MAP[field]
+    reduce_mode = _CONTACT_REDUCE_MAP[self.cfg.reduce]
+    intprm = [data_bits, reduce_mode, self.cfg.num_slots]
+
+    kwargs: dict[str, Any] = {
+      "name": sensor_name,
+      "type": mujoco.mjtSensor.mjSENS_CONTACT,
+      "objtype": _MODE_TO_OBJTYPE[self.cfg.primary.mode],
+      "objname": _prefix_name(primary_name, self.cfg.primary.entity),
+      "intprm": intprm,
+    }
+
+    if secondary_name is not None:
+      assert self.cfg.secondary is not None
+      kwargs["reftype"] = _MODE_TO_OBJTYPE[self.cfg.secondary.mode]
+      kwargs["refname"] = _prefix_name(secondary_name, self.cfg.secondary.entity)
+
+    if self.cfg.debug:
+      self._print_debug(sensor_name, field, intprm, kwargs)
+
+    scene_spec.add_sensor(**kwargs)
+
+  def _print_debug(
+    self,
+    sensor_name: str,
+    field: str,
+    intprm: list[int],
+    kwargs: dict[str, Any],
+  ) -> None:
+    objtype_name = _objtype_name(kwargs["objtype"])
+    reftype_val = kwargs.get("reftype")
+    refname_val = kwargs.get("refname")
+    if refname_val is None:
+      ref_str = "<any>"
+    else:
+      ref_str = f"{_objtype_name(reftype_val)}:{refname_val}"
+    print(
+      "Adding contact sensor\n"
+      f"  name    : {sensor_name}\n"
+      f"  object  : {objtype_name}:{kwargs['objname']}\n"
+      f"  ref     : {ref_str}\n"
+      f"  field   : {field}  bits=0b{intprm[0]:b}\n"
+      f"  reduce  : {self.cfg.reduce}  num_slots={self.cfg.num_slots}"
+    )
+
+
+def _prefix_name(name: str, entity: str | None) -> str:
+  """Prepend ``entity/`` to a MuJoCo name when an entity scope is set."""
+  if entity:
+    return f"{entity}/{name}"
+  return name
+
+
+def _objtype_name(objtype: Any) -> str:
+  """Pretty-print a MuJoCo object type, dropping the ``mjOBJ_`` prefix."""
+  return getattr(objtype, "name", str(objtype)).removeprefix("mjOBJ_")
diff --git a/src/mjlab/sensor/raycast_sensor.py b/src/mjlab/sensor/raycast_sensor.py
new file mode 100644
index 0000000..0d89f61
--- /dev/null
+++ b/src/mjlab/sensor/raycast_sensor.py
@@ -0,0 +1,886 @@
+"""Raycast sensor for terrain and obstacle detection.
+
+Provides :class:`RayCastSensor` and :class:`RayCastSensorCfg` for BVH-accelerated
+raycasting with grid, pinhole camera, and ring patterns. Supports multi-frame
+attachment, configurable ray alignment, and geom group filtering.
+
+See :doc:`/sensors/raycast_sensor` for usage guide and examples.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Literal
+
+import mujoco
+import mujoco_warp as mjwarp
+import torch
+import warp as wp
+from mujoco_warp import rays
+
+from mjlab.entity import Entity
+from mjlab.sensor.builtin_sensor import ObjRef
+from mjlab.sensor.sensor import Sensor, SensorCfg
+from mjlab.utils.lab_api.math import quat_from_matrix
+
+if TYPE_CHECKING:
+  from mjlab.sensor.sensor_context import SensorContext
+  from mjlab.viewer.debug_visualizer import DebugVisualizer
+
+RayAlignment = Literal["base", "yaw", "world"]
+
+# NOTE: Not publicly exposed by mujoco_warp.
+_vec6 = wp.types.vector(length=6, dtype=float)
+_ALL_GROUPS = _vec6(-1, -1, -1, -1, -1, -1)
+
+
+def _geom_groups_to_vec6(groups: tuple[int, ...] | None):  # -> _vec6
+  """Convert geom group tuple to mujoco_warp vec6 format.
+
+  In the vec6 format, -1 means include and 0 means exclude.
+  """
+  if groups is None:
+    return _ALL_GROUPS
+  out = [0, 0, 0, 0, 0, 0]
+  for g in groups:
+    if not 0 <= g < mujoco.mjNGROUP:
+      raise ValueError(
+        f"include_geom_groups must be in [0, {mujoco.mjNGROUP}), got {g}"
+      )
+    out[g] = -1
+  return _vec6(*out)
+
+
+@dataclass
+class GridPatternCfg:
+  """Grid pattern - parallel rays in a 2D grid."""
+
+  size: tuple[float, float] = (1.0, 1.0)
+  """Grid size (length, width) in meters."""
+
+  resolution: float = 0.1
+  """Spacing between rays in meters."""
+
+  direction: tuple[float, float, float] = (0.0, 0.0, -1.0)
+  """Ray direction in frame-local coordinates."""
+
+  def generate_rays(
+    self, mj_model: mujoco.MjModel | None, device: str
+  ) -> tuple[torch.Tensor, torch.Tensor]:
+    """Generate ray pattern.
+
+    Args:
+      mj_model: MuJoCo model (unused for grid pattern).
+      device: Device for tensor operations.
+
+    Returns:
+      Tuple of (local_offsets [N, 3], local_directions [N, 3]).
+    """
+    del mj_model  # Unused for grid pattern
+    size_x, size_y = self.size
+    res = self.resolution
+
+    x = torch.arange(
+      -size_x / 2, size_x / 2 + res * 0.5, res, device=device, dtype=torch.float32
+    )
+    y = torch.arange(
+      -size_y / 2, size_y / 2 + res * 0.5, res, device=device, dtype=torch.float32
+    )
+    grid_x, grid_y = torch.meshgrid(x, y, indexing="xy")
+
+    num_rays = grid_x.numel()
+    local_offsets = torch.zeros((num_rays, 3), device=device, dtype=torch.float32)
+    local_offsets[:, 0] = grid_x.flatten()
+    local_offsets[:, 1] = grid_y.flatten()
+
+    # All rays share the same direction for grid pattern.
+    direction = torch.tensor(self.direction, device=device, dtype=torch.float32)
+    direction = direction / direction.norm()
+    local_directions = direction.unsqueeze(0).expand(num_rays, 3).clone()
+
+    return local_offsets, local_directions
+
+
+@dataclass
+class PinholeCameraPatternCfg:
+  """Pinhole camera pattern - rays diverging from origin like a camera.
+
+  Can be configured with explicit parameters (width, height, fovy) or created
+  via factory methods like from_mujoco_camera() or from_intrinsic_matrix().
+  """
+
+  width: int = 16
+  """Image width in pixels."""
+
+  height: int = 12
+  """Image height in pixels."""
+
+  fovy: float = 45.0
+  """Vertical field of view in degrees (matches MuJoCo convention)."""
+
+  _camera_name: str | None = field(default=None, repr=False)
+  """Internal: MuJoCo camera name for deferred parameter resolution."""
+
+  @classmethod
+  def from_mujoco_camera(cls, camera_name: str) -> PinholeCameraPatternCfg:
+    """Create config that references a MuJoCo camera.
+
+    Camera parameters (resolution, FOV) are resolved at runtime from the model.
+
+    Args:
+      camera_name: Name of the MuJoCo camera to reference.
+
+    Returns:
+      Config that will resolve parameters from the MuJoCo camera.
+    """
+    # Placeholder values; actual values resolved in generate_rays().
+    return cls(width=0, height=0, fovy=0.0, _camera_name=camera_name)
+
+  @classmethod
+  def from_intrinsic_matrix(
+    cls, intrinsic_matrix: list[float], width: int, height: int
+  ) -> PinholeCameraPatternCfg:
+    """Create from 3x3 intrinsic matrix [fx, 0, cx, 0, fy, cy, 0, 0, 1].
+
+    Args:
+      intrinsic_matrix: Flattened 3x3 intrinsic matrix.
+      width: Image width in pixels.
+      height: Image height in pixels.
+
+    Returns:
+      Config with fovy computed from the intrinsic matrix.
+    """
+    fy = intrinsic_matrix[4]  # fy is at position [1,1] in the matrix
+    fovy = 2 * math.atan(height / (2 * fy)) * 180 / math.pi
+    return cls(width=width, height=height, fovy=fovy)
+
+  def generate_rays(
+    self, mj_model: mujoco.MjModel | None, device: str
+  ) -> tuple[torch.Tensor, torch.Tensor]:
+    """Generate ray pattern.
+
+    Args:
+      mj_model: MuJoCo model (required if using from_mujoco_camera).
+      device: Device for tensor operations.
+
+    Returns:
+      Tuple of (local_offsets [N, 3], local_directions [N, 3]).
+    """
+    # Resolve camera parameters.
+    if self._camera_name is not None:
+      if mj_model is None:
+        raise ValueError("MuJoCo model required when using from_mujoco_camera()")
+      # Get parameters from MuJoCo camera.
+      cam_id = mj_model.camera(self._camera_name).id
+      width, height = mj_model.cam_resolution[cam_id]
+
+      # MuJoCo has two camera modes:
+      # 1. fovy mode: sensorsize is zero, use cam_fovy directly
+      # 2. Physical sensor mode: sensorsize > 0, compute from focal/sensorsize
+      sensorsize = mj_model.cam_sensorsize[cam_id]
+      if sensorsize[0] > 0 and sensorsize[1] > 0:
+        # Physical sensor model.
+        intrinsic = mj_model.cam_intrinsic[cam_id]  # [fx, fy, cx, cy]
+        focal = intrinsic[:2]  # [fx, fy]
+        h_fov_rad = 2 * math.atan(sensorsize[0] / (2 * focal[0]))
+        v_fov_rad = 2 * math.atan(sensorsize[1] / (2 * focal[1]))
+      else:
+        # Read vertical FOV directly from MuJoCo.
+        v_fov_rad = math.radians(mj_model.cam_fovy[cam_id])
+        aspect = width / height
+        h_fov_rad = 2 * math.atan(math.tan(v_fov_rad / 2) * aspect)
+    else:
+      # Use explicit parameters.
+      width = self.width
+      height = self.height
+      v_fov_rad = math.radians(self.fovy)
+      aspect = width / height
+      h_fov_rad = 2 * math.atan(math.tan(v_fov_rad / 2) * aspect)
+
+    # Create normalized pixel coordinates [-1, 1].
+    u = torch.linspace(-1, 1, width, device=device, dtype=torch.float32)
+    v = torch.linspace(-1, 1, height, device=device, dtype=torch.float32)
+    grid_u, grid_v = torch.meshgrid(u, v, indexing="xy")
+
+    # Convert to ray directions (MuJoCo camera: -Z forward, +X right, +Y down).
+    ray_x = grid_u.flatten() * math.tan(h_fov_rad / 2)
+    ray_y = grid_v.flatten() * math.tan(v_fov_rad / 2)
+    ray_z = -torch.ones_like(ray_x)  # Negative Z for MuJoCo camera forward
+
+    num_rays = width * height
+    local_offsets = torch.zeros((num_rays, 3), device=device)
+    local_directions = torch.stack([ray_x, ray_y, ray_z], dim=1)
+    local_directions = local_directions / local_directions.norm(dim=1, keepdim=True)
+
+    return local_offsets, local_directions
+
+
+@dataclass
+class RingPatternCfg:
+  """Ring pattern - rays in concentric rings around the origin.
+
+  Useful for per-site height sensing where you want to sample the
+  terrain around each attachment frame.
+  """
+
+  @dataclass
+  class Ring:
+    """A single ring in the pattern."""
+
+    radius: float
+    """Radius of this ring in meters."""
+
+    num_samples: int
+    """Number of evenly spaced sample points on this ring."""
+
+  rings: tuple[Ring, ...]
+  """Ring definitions. Multiple rings create a concentric pattern."""
+
+  include_center: bool = True
+  """Whether to include a ray at the center (zero offset)."""
+
+  direction: tuple[float, float, float] = (0.0, 0.0, -1.0)
+  """Ray direction in frame-local coordinates."""
+
+  @classmethod
+  def single_ring(
+    cls,
+    radius: float = 0.1,
+    num_samples: int = 8,
+    include_center: bool = True,
+    direction: tuple[float, float, float] = (0.0, 0.0, -1.0),
+  ) -> RingPatternCfg:
+    """Create a single-ring pattern.
+
+    Args:
+      radius: Ring radius in meters.
+      num_samples: Number of evenly spaced points on the ring.
+      include_center: Whether to include a center ray.
+      direction: Ray direction in frame-local coordinates.
+
+    Returns:
+      RingPatternCfg with one ring.
+    """
+    return cls(
+      rings=(cls.Ring(radius, num_samples),),
+      include_center=include_center,
+      direction=direction,
+    )
+
+  def generate_rays(
+    self, mj_model: mujoco.MjModel | None, device: str
+  ) -> tuple[torch.Tensor, torch.Tensor]:
+    """Generate ray pattern.
+
+    Args:
+      mj_model: MuJoCo model (unused for ring pattern).
+      device: Device for tensor operations.
+
+    Returns:
+      Tuple of (local_offsets [N, 3], local_directions [N, 3]).
+    """
+    del mj_model
+    offsets: list[torch.Tensor] = []
+
+    if self.include_center:
+      offsets.append(torch.zeros(3, device=device, dtype=torch.float32))
+
+    for ring in self.rings:
+      for i in range(ring.num_samples):
+        angle = 2.0 * math.pi * i / ring.num_samples
+        offsets.append(
+          torch.tensor(
+            [
+              ring.radius * math.cos(angle),
+              ring.radius * math.sin(angle),
+              0.0,
+            ],
+            device=device,
+            dtype=torch.float32,
+          )
+        )
+
+    local_offsets = torch.stack(offsets)  # [N, 3]
+    num_rays = local_offsets.shape[0]
+
+    direction = torch.tensor(self.direction, device=device, dtype=torch.float32)
+    direction = direction / direction.norm()
+    local_directions = direction.unsqueeze(0).expand(num_rays, 3).clone()
+
+    return local_offsets, local_directions
+
+
+PatternCfg = GridPatternCfg | PinholeCameraPatternCfg | RingPatternCfg
+
+
+@dataclass
+class RayCastData:
+  """Raycast sensor output data.
+
+  Note:
+    Fields are views into GPU buffers and are valid until the next
+    ``sense()`` call.
+  """
+
+  distances: torch.Tensor
+  """[B, N] Distance to hit point. -1 if no hit.
+
+  N = num_frames * num_rays_per_frame.
+  """
+
+  normals_w: torch.Tensor
+  """[B, N, 3] Surface normal at hit point (world frame). Zero if no hit."""
+
+  hit_pos_w: torch.Tensor
+  """[B, N, 3] Hit position in world frame. Ray origin if no hit."""
+
+  pos_w: torch.Tensor
+  """[B, 3] First frame position in world coordinates."""
+
+  quat_w: torch.Tensor
+  """[B, 4] First frame orientation quaternion (w, x, y, z)."""
+
+  frame_pos_w: torch.Tensor
+  """[B, F, 3] All frame positions in world coordinates."""
+
+  frame_quat_w: torch.Tensor
+  """[B, F, 4] All frame orientations (w, x, y, z)."""
+
+
+@dataclass
+class RayCastSensorCfg(SensorCfg):
+  """Raycast sensor configuration.
+
+  Supports multiple ray patterns (grid, pinhole camera, ring) and alignment modes.
+  """
+
+  @dataclass
+  class VizCfg:
+    """Visualization settings for debug rendering."""
+
+    hit_color: tuple[float, float, float, float] = (0.0, 1.0, 0.0, 0.8)
+    """RGBA color for rays that hit a surface."""
+
+    miss_color: tuple[float, float, float, float] = (1.0, 0.0, 0.0, 0.4)
+    """RGBA color for rays that miss."""
+
+    hit_sphere_color: tuple[float, float, float, float] = (0.0, 1.0, 1.0, 1.0)
+    """RGBA color for spheres drawn at hit points."""
+
+    hit_sphere_radius: float = 0.5
+    """Radius of spheres drawn at hit points (multiplier of meansize)."""
+
+    show_rays: bool = False
+    """Whether to draw ray arrows."""
+
+    show_normals: bool = False
+    """Whether to draw surface normals at hit points."""
+
+    normal_color: tuple[float, float, float, float] = (1.0, 1.0, 0.0, 1.0)
+    """RGBA color for surface normal arrows."""
+
+    normal_length: float = 5.0
+    """Length of surface normal arrows (multiplier of meansize)."""
+
+  frame: ObjRef | tuple[ObjRef, ...]
+  """Body, site, or geom to attach rays to.
+
+  Pass a single ``ObjRef`` for one frame, or a tuple for multi-frame
+  sensing (e.g. per-foot height sensors). Each frame's parent body is
+  excluded independently when ``exclude_parent_body`` is True.
+  """
+
+  pattern: PatternCfg = field(default_factory=GridPatternCfg)
+  """Ray pattern configuration. Defaults to GridPatternCfg."""
+
+  ray_alignment: RayAlignment = "base"
+  """How rays are oriented relative to the frame. Controls direction only;
+  the ray origin is always the physical frame position (``site_xpos`` /
+  ``geom_xpos`` / ``body_xpos``).
+
+  - "base": Full rotation (default). Rays rotate with the body.
+  - "yaw": Yaw only, ignores pitch/roll (good for height maps).
+  - "world": Fixed in world frame, rays always point the same direction.
+  """
+
+  max_distance: float = 10.0
+  """Maximum ray distance. Rays beyond this report -1."""
+
+  exclude_parent_body: bool = True
+  """Exclude parent body from ray intersection tests."""
+
+  include_geom_groups: tuple[int, ...] | None = (0, 1, 2)
+  """Geom groups (0-5) to include in raycasting.
+
+  Defaults to (0, 1, 2). Set to None to include all groups.
+  """
+
+  debug_vis: bool = False
+  """Enable debug visualization."""
+
+  viz: VizCfg = field(default_factory=VizCfg)
+  """Visualization settings."""
+
+  def build(self) -> RayCastSensor:
+    return RayCastSensor(self)
+
+
+class RayCastSensor(Sensor[RayCastData]):
+  """Raycast sensor for terrain and obstacle detection."""
+
+  requires_sensor_context = True
+
+  def __init__(self, cfg: RayCastSensorCfg) -> None:
+    super().__init__()
+    self.cfg = cfg
+    self._data: mjwarp.Data | None = None
+    self._model: mjwarp.Model | None = None
+    self._mj_model: mujoco.MjModel | None = None
+    self._device: str | None = None
+    self._wp_device: wp.Device | None = None
+
+    # Per-frame info: list of (frame_type, obj_id, body_id).
+    self._frame_infos: list[tuple[Literal["body", "site", "geom"], int, int]] = []
+    self._num_frames: int = 0
+    self._num_rays_per_frame: int = 0
+
+    self._local_offsets: torch.Tensor | None = None
+    self._local_directions: torch.Tensor | None = None  # [rays_per_frame, 3]
+    self._num_rays: int = 0
+
+    self._ray_pnt: wp.array | None = None
+    self._ray_vec: wp.array | None = None
+    self._ray_dist: wp.array | None = None
+    self._ray_geomid: wp.array | None = None
+    self._ray_normal: wp.array | None = None
+    self._ray_bodyexclude: wp.array | None = None
+    self._geomgroup = _vec6(-1, -1, -1, -1, -1, -1)
+
+    self._distances: torch.Tensor | None = None
+    self._normals_w: torch.Tensor | None = None
+    self._hit_pos_w: torch.Tensor | None = None
+    self._pos_w: torch.Tensor | None = None
+    self._quat_w: torch.Tensor | None = None
+    self._frame_pos_w: torch.Tensor | None = None
+    self._frame_quat_w: torch.Tensor | None = None
+
+    self._cached_world_origins: torch.Tensor | None = None
+    self._cached_world_rays: torch.Tensor | None = None
+    self._cached_frame_pos: torch.Tensor | None = None
+    self._cached_frame_mat: torch.Tensor | None = None
+
+    self._debug_vis_enabled: bool = True
+    self._ctx: SensorContext | None = None
+
+  def edit_spec(
+    self,
+    scene_spec: mujoco.MjSpec,
+    entities: dict[str, Entity],
+  ) -> None:
+    del scene_spec, entities
+
+  def initialize(
+    self,
+    mj_model: mujoco.MjModel,
+    model: mjwarp.Model,
+    data: mjwarp.Data,
+    device: str,
+  ) -> None:
+    self._data = data
+    self._model = model
+    self._mj_model = mj_model
+    self._device = device
+    self._wp_device = wp.get_device(device)
+    num_envs = data.nworld
+
+    # Normalize frame to tuple.
+    frames = self.cfg.frame
+    if isinstance(frames, ObjRef):
+      frames = (frames,)
+
+    # Resolve per-frame IDs.
+    self._frame_infos = []
+    for frame in frames:
+      frame_name = frame.prefixed_name()
+      info: tuple[Literal["body", "site", "geom"], int, int]
+      if frame.type == "body":
+        bid = mj_model.body(frame_name).id
+        info = ("body", bid, bid)
+      elif frame.type == "site":
+        sid = mj_model.site(frame_name).id
+        info = ("site", sid, int(mj_model.site_bodyid[sid]))
+      elif frame.type == "geom":
+        gid = mj_model.geom(frame_name).id
+        info = ("geom", gid, int(mj_model.geom_bodyid[gid]))
+      else:
+        raise ValueError(
+          f"RayCastSensor frame must be 'body', 'site', or 'geom', got '{frame.type}'"
+        )
+      self._frame_infos.append(info)
+    self._num_frames = len(self._frame_infos)
+
+    # Generate ray pattern.
+    pattern = self.cfg.pattern
+    self._local_offsets, self._local_directions = pattern.generate_rays(
+      mj_model, device
+    )
+    self._num_rays_per_frame = self._local_offsets.shape[0]
+    self._num_rays = self._num_frames * self._num_rays_per_frame
+
+    self._ray_pnt = wp.zeros((num_envs, self._num_rays), dtype=wp.vec3, device=device)
+    self._ray_vec = wp.zeros((num_envs, self._num_rays), dtype=wp.vec3, device=device)
+    self._ray_dist = wp.zeros((num_envs, self._num_rays), dtype=float, device=device)
+    self._ray_geomid = wp.zeros((num_envs, self._num_rays), dtype=int, device=device)
+    self._ray_normal = wp.zeros(
+      (num_envs, self._num_rays), dtype=wp.vec3, device=device
+    )
+
+    # Body exclusion: each frame's body_id repeated N times.
+    if self.cfg.exclude_parent_body:
+      body_excludes: list[int] = []
+      for _, _, body_id in self._frame_infos:
+        body_excludes.extend([body_id] * self._num_rays_per_frame)
+    else:
+      body_excludes = [-1] * self._num_rays
+    self._ray_bodyexclude = wp.array(body_excludes, dtype=int, device=device)
+
+    self._geomgroup = _geom_groups_to_vec6(self.cfg.include_geom_groups)
+
+    # Pre-allocate output tensors so shape inference works before
+    # the first sense() call.
+    F = self._num_frames
+    self._distances = torch.zeros(num_envs, self._num_rays, device=device)
+    self._normals_w = torch.zeros(num_envs, self._num_rays, 3, device=device)
+    self._hit_pos_w = torch.zeros(num_envs, self._num_rays, 3, device=device)
+    self._pos_w = torch.zeros(num_envs, 3, device=device)
+    self._quat_w = torch.zeros(num_envs, 4, device=device)
+    self._frame_pos_w = torch.zeros(num_envs, F, 3, device=device)
+    self._frame_quat_w = torch.zeros(num_envs, F, 4, device=device)
+
+    assert self._wp_device is not None
+
+  @property
+  def include_geom_groups(self) -> tuple[int, ...] | None:
+    return self.cfg.include_geom_groups
+
+  def set_context(self, ctx: SensorContext) -> None:
+    """Wire this sensor to a SensorContext for BVH-accelerated raycasting."""
+    self._ctx = ctx
+
+  def _compute_data(self) -> RayCastData:
+    if self._ctx is None:
+      raise RuntimeError(
+        "RayCastSensor requires a SensorContext. "
+        "Ensure the sensor is part of a scene with "
+        "sim.sense() calls."
+      )
+    assert self._distances is not None and self._normals_w is not None
+    assert self._hit_pos_w is not None
+    assert self._pos_w is not None and self._quat_w is not None
+    assert self._frame_pos_w is not None and self._frame_quat_w is not None
+    return RayCastData(
+      distances=self._distances,
+      normals_w=self._normals_w,
+      hit_pos_w=self._hit_pos_w,
+      pos_w=self._pos_w,
+      quat_w=self._quat_w,
+      frame_pos_w=self._frame_pos_w,
+      frame_quat_w=self._frame_quat_w,
+    )
+
+  @property
+  def num_rays(self) -> int:
+    """Total number of rays (num_frames * num_rays_per_frame)."""
+    return self._num_rays
+
+  @property
+  def num_frames(self) -> int:
+    """Number of attachment frames."""
+    return self._num_frames
+
+  @property
+  def num_rays_per_frame(self) -> int:
+    """Number of rays per attachment frame."""
+    return self._num_rays_per_frame
+
+  def debug_vis(self, visualizer: DebugVisualizer) -> None:
+    if not self.cfg.debug_vis or not self._debug_vis_enabled:
+      return
+    assert self._data is not None
+    assert self._local_offsets is not None
+    assert self._local_directions is not None
+    assert self._cached_frame_pos is not None
+    assert self._cached_frame_mat is not None
+
+    data = self.data
+    env_indices = list(visualizer.get_env_indices(data.distances.shape[0]))
+    if not env_indices:
+      return
+
+    F = self._num_frames
+    N = self._num_rays_per_frame
+
+    # Use cached frame poses [B, F, 3] / [B, F, 3, 3].
+    frame_pos = self._cached_frame_pos[env_indices]  # [K, F, 3]
+    frame_mat = self._cached_frame_mat[env_indices]  # [K, F, 3, 3]
+
+    K_envs = len(env_indices)
+    # Compute alignment rotation for all frames.
+    rot_mats = (
+      self._compute_alignment_rotation(frame_mat.view(K_envs * F, 3, 3))
+      .view(K_envs, F, 3, 3)
+      .cpu()
+      .numpy()
+    )
+    origins = frame_pos.cpu().numpy()
+    offsets = self._local_offsets.cpu().numpy()
+    directions = self._local_directions.cpu().numpy()
+    hit_positions = data.hit_pos_w[env_indices].cpu().numpy()
+    distances = data.distances[env_indices].cpu().numpy()
+    normals = data.normals_w[env_indices].cpu().numpy()
+
+    meansize = visualizer.meansize
+    ray_width = 0.1 * meansize
+    sphere_radius = self.cfg.viz.hit_sphere_radius * meansize
+    normal_length = self.cfg.viz.normal_length * meansize
+    normal_width = 0.1 * meansize
+    miss_extent = min(0.5, self.cfg.max_distance * 0.05)
+    name = self.cfg.name
+
+    for k in range(K_envs):
+      for f in range(F):
+        rot = rot_mats[k, f]
+        for i in range(N):
+          ray_idx = f * N + i
+          origin = origins[k, f] + rot @ offsets[i]
+          hit = distances[k, ray_idx] >= 0
+
+          if hit:
+            end = hit_positions[k, ray_idx]
+            color = self.cfg.viz.hit_color
+          else:
+            end = origin + rot @ directions[i] * miss_extent
+            color = self.cfg.viz.miss_color
+
+          if self.cfg.viz.show_rays:
+            visualizer.add_arrow(
+              start=origin,
+              end=end,
+              color=color,
+              width=ray_width,
+              label=f"{name}_ray_{ray_idx}",
+            )
+
+          if hit:
+            visualizer.add_sphere(
+              center=end,
+              radius=sphere_radius,
+              color=self.cfg.viz.hit_sphere_color,
+              label=f"{name}_hit_{ray_idx}",
+            )
+            if self.cfg.viz.show_normals:
+              normal_end = end + normals[k, ray_idx] * normal_length
+              visualizer.add_arrow(
+                start=end,
+                end=normal_end,
+                color=self.cfg.viz.normal_color,
+                width=normal_width,
+                label=f"{name}_normal_{ray_idx}",
+              )
+
+  # Private methods.
+
+  def prepare_rays(self) -> None:
+    """PRE-GRAPH: Transform local rays to world frame.
+
+    Reads body/site/geom poses via PyTorch and writes world-frame ray
+    origins and directions into Warp arrays. Caches the frame pose and
+    world-frame tensors for postprocess_rays().
+    """
+    assert self._data is not None and self._model is not None
+    assert self._local_offsets is not None and self._local_directions is not None
+
+    # Gather per-frame poses: [B, F, 3] and [B, F, 3, 3].
+    # Position is always the physical world position. Alignment only
+    # affects ray directions (applied to frame_mat below).
+    pos_list: list[torch.Tensor] = []
+    mat_list: list[torch.Tensor] = []
+    for frame_type, obj_id, _ in self._frame_infos:
+      if frame_type == "body":
+        pos_list.append(self._data.xpos[:, obj_id])
+        mat_list.append(self._data.xmat[:, obj_id].view(-1, 3, 3))
+      elif frame_type == "site":
+        pos_list.append(self._data.site_xpos[:, obj_id])
+        mat_list.append(self._data.site_xmat[:, obj_id].view(-1, 3, 3))
+      else:  # geom
+        pos_list.append(self._data.geom_xpos[:, obj_id])
+        mat_list.append(self._data.geom_xmat[:, obj_id].view(-1, 3, 3))
+
+    frame_pos = torch.stack(pos_list, dim=1)  # [B, F, 3]
+    frame_mat = torch.stack(mat_list, dim=1)  # [B, F, 3, 3]
+
+    B, F = frame_pos.shape[:2]
+    N = self._num_rays_per_frame
+
+    # Compute alignment rotation for all frames at once.
+    rot_mat = self._compute_alignment_rotation(frame_mat.reshape(B * F, 3, 3)).reshape(
+      B, F, 3, 3
+    )
+
+    # Compute world offsets and directions: [B, F, N, 3].
+    world_offsets = torch.einsum("bfij,nj->bfni", rot_mat, self._local_offsets)
+    world_origins = frame_pos[:, :, None, :] + world_offsets
+    world_rays = torch.einsum("bfij,nj->bfni", rot_mat, self._local_directions)
+
+    # Flatten to [B, F*N, 3] for raycasting.
+    world_origins_flat = world_origins.reshape(B, F * N, 3)
+    world_rays_flat = world_rays.reshape(B, F * N, 3)
+
+    assert self._ray_pnt is not None and self._ray_vec is not None
+    pnt_torch = wp.to_torch(self._ray_pnt).view(B, self._num_rays, 3)
+    vec_torch = wp.to_torch(self._ray_vec).view(B, self._num_rays, 3)
+    pnt_torch.copy_(world_origins_flat)
+    vec_torch.copy_(world_rays_flat)
+
+    # Cache for postprocess_rays() and debug_vis().
+    self._cached_world_origins = world_origins_flat
+    self._cached_world_rays = world_rays_flat
+    self._cached_frame_pos = frame_pos  # [B, F, 3]
+    self._cached_frame_mat = frame_mat  # [B, F, 3, 3]
+
+  def raycast_kernel(self, rc: mjwarp.RenderContext) -> None:
+    """IN-GRAPH: Execute BVH-accelerated raycast kernel."""
+    assert self._ray_pnt is not None
+    assert self._ray_vec is not None
+    assert self._ray_bodyexclude is not None
+    assert self._ray_dist is not None
+    assert self._ray_geomid is not None
+    assert self._ray_normal is not None
+    rays(
+      m=self._model.struct,  # type: ignore[attr-defined]
+      d=self._data.struct,  # type: ignore[attr-defined]
+      pnt=self._ray_pnt,  # type: ignore[invalid-argument-type]
+      vec=self._ray_vec,  # type: ignore[invalid-argument-type]
+      geomgroup=self._geomgroup,  # pyright: ignore[reportArgumentType]
+      flg_static=True,
+      bodyexclude=self._ray_bodyexclude,
+      dist=self._ray_dist,  # type: ignore[invalid-argument-type]
+      geomid=self._ray_geomid,  # type: ignore[invalid-argument-type]
+      normal=self._ray_normal,  # type: ignore[invalid-argument-type]
+      rc=rc,
+    )
+
+  def postprocess_rays(self) -> None:
+    """POST-GRAPH: Convert Warp outputs to PyTorch, compute hit positions."""
+    assert self._cached_world_origins is not None
+    assert self._cached_world_rays is not None
+    assert self._cached_frame_pos is not None
+    assert self._cached_frame_mat is not None
+
+    B = self._cached_frame_pos.shape[0]
+    F = self._num_frames
+
+    assert self._ray_dist is not None and self._ray_normal is not None
+    distances = wp.to_torch(self._ray_dist)
+    normals_w = wp.to_torch(self._ray_normal).view(B, self._num_rays, 3)
+    distances.masked_fill_(distances > self.cfg.max_distance, -1.0)
+
+    hit_mask = distances >= 0
+    # ``origin + ray * max(distance, 0)`` collapses miss rays to ``origin``
+    # (clamped distance is 0) without any branching.
+    clamped = distances.clamp(min=0.0)
+    self._hit_pos_w = (
+      self._cached_world_origins + self._cached_world_rays * clamped.unsqueeze(-1)
+    )
+
+    # Zero out normals for misses.
+    normals_w.masked_fill_(~hit_mask.unsqueeze(-1), 0.0)
+    self._distances = distances
+    self._normals_w = normals_w
+
+    # All frames: [B, F, 3] / [B, F, 4].
+    self._frame_pos_w = self._cached_frame_pos
+    self._frame_quat_w = quat_from_matrix(
+      self._cached_frame_mat.reshape(B * F, 3, 3)
+    ).reshape(B, F, 4)
+
+    # First frame for backward compat: [B, 3] / [B, 4].
+    assert self._frame_pos_w is not None and self._frame_quat_w is not None
+    self._pos_w = self._frame_pos_w[:, 0]
+    self._quat_w = self._frame_quat_w[:, 0]
+
+    # ``sense()`` runs after the decimation loop (which invalidates the cache)
+    # and after rewards may have already read ``.data``, repopulating the cache
+    # with pre-sense hit positions. Rebinding the tensors above leaves that
+    # cache pointing at the previous step's data, so invalidate here to force a
+    # recompute on the next ``.data`` access. Otherwise observations and debug
+    # visualization would lag one step behind the freshly sensed hits (#998).
+    self._invalidate_cache()
+
+  def _compute_alignment_rotation(self, frame_mat: torch.Tensor) -> torch.Tensor:
+    """Compute rotation matrix based on ray_alignment setting."""
+    if self.cfg.ray_alignment == "base":
+      # Full rotation.
+      return frame_mat
+    elif self.cfg.ray_alignment == "yaw":
+      # Extract yaw only, zero out pitch/roll.
+      return self._extract_yaw_rotation(frame_mat)
+    elif self.cfg.ray_alignment == "world":
+      # Identity rotation (world-aligned).
+      num_envs = frame_mat.shape[0]
+      return (
+        torch.eye(3, device=frame_mat.device, dtype=frame_mat.dtype)
+        .unsqueeze(0)
+        .expand(num_envs, -1, -1)
+      )
+    else:
+      raise ValueError(f"Unknown ray_alignment: {self.cfg.ray_alignment}")
+
+  def _extract_yaw_rotation(self, rot_mat: torch.Tensor) -> torch.Tensor:
+    """Extract yaw-only rotation matrix (rotation around Z axis).
+
+    Handles the singularity at ±90° pitch by falling back to the Y-axis
+    when the X-axis projection onto the XY plane is too small.
+    """
+    batch_size = rot_mat.shape[0]
+    device = rot_mat.device
+    dtype = rot_mat.dtype
+
+    # Project X-axis onto XY plane.
+    x_axis = rot_mat[:, :, 0]  # First column [B, 3]
+    x_proj = x_axis.clone()
+    x_proj[:, 2] = 0  # Zero out Z component
+    x_norm = x_proj.norm(dim=1)  # [B]
+
+    # Check for singularity (X-axis nearly vertical).
+    threshold = 0.1
+    singular = x_norm < threshold  # [B]
+
+    # For singular cases, use Y-axis instead.
+    if singular.any():
+      y_axis = rot_mat[:, :, 1]  # Second column [B, 3]
+      y_proj = y_axis.clone()
+      y_proj[:, 2] = 0
+      y_norm = y_proj.norm(dim=1).clamp(min=1e-6)
+      y_proj = y_proj / y_norm.unsqueeze(-1)
+      # Y-axis points left; rotate -90° around Z to get forward direction.
+      # [y_x, y_y] -> [y_y, -y_x]
+      x_from_y = torch.zeros_like(y_proj)
+      x_from_y[:, 0] = y_proj[:, 1]
+      x_from_y[:, 1] = -y_proj[:, 0]
+      x_proj[singular] = x_from_y[singular]
+      x_norm[singular] = 1.0  # Already normalized
+
+    # Normalize X projection.
+    x_norm = x_norm.clamp(min=1e-6)
+    x_proj = x_proj / x_norm.unsqueeze(-1)
+
+    # Build yaw-only rotation matrix.
+    yaw_mat = torch.zeros((batch_size, 3, 3), device=device, dtype=dtype)
+    yaw_mat[:, 0, 0] = x_proj[:, 0]
+    yaw_mat[:, 1, 0] = x_proj[:, 1]
+    yaw_mat[:, 0, 1] = -x_proj[:, 1]
+    yaw_mat[:, 1, 1] = x_proj[:, 0]
+    yaw_mat[:, 2, 2] = 1
+    return yaw_mat
diff --git a/src/mjlab/sensor/sensor.py b/src/mjlab/sensor/sensor.py
new file mode 100644
index 0000000..913b0ca
--- /dev/null
+++ b/src/mjlab/sensor/sensor.py
@@ -0,0 +1,162 @@
+"""Base sensor interface."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
+
+import mujoco
+import mujoco_warp as mjwarp
+import torch
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+  from mjlab.viewer.debug_visualizer import DebugVisualizer
+
+
+T = TypeVar("T")
+
+
+@dataclass
+class SensorCfg(ABC):
+  """Base configuration for a sensor."""
+
+  name: str
+
+  @property
+  def prefixed_name(self) -> str:
+    """The sensor name as it appears in the MuJoCo model."""
+    return self.name
+
+  @abstractmethod
+  def build(self) -> Sensor[Any]:
+    """Build sensor instance from this config."""
+    raise NotImplementedError
+
+
+class Sensor(ABC, Generic[T]):
+  """Base sensor interface with typed data and per-step caching.
+
+  Type parameter T specifies the type of data returned by the sensor. For example:
+  - Sensor[torch.Tensor] for sensors returning raw tensors
+  - Sensor[ContactData] for sensors returning structured contact data
+
+  Subclasses should not forget to:
+  - Call `super().__init__()` in their `__init__` method
+  - If overriding `reset()` or `update()`, call `super()` FIRST to invalidate cache
+  """
+
+  requires_sensor_context: bool = False
+  """Whether this sensor needs a SensorContext (render context)."""
+
+  def __init__(self) -> None:
+    self._cached_data: T | None = None
+    self._cache_valid: bool = False
+
+  @abstractmethod
+  def edit_spec(
+    self,
+    scene_spec: mujoco.MjSpec,
+    entities: dict[str, Entity],
+  ) -> None:
+    """Edit the scene spec to add this sensor.
+
+    This is called during scene construction to add sensor elements
+    to the MjSpec.
+
+    Args:
+      scene_spec: The scene MjSpec to edit.
+      entities: Dictionary of entities in the scene, keyed by name.
+    """
+    raise NotImplementedError
+
+  @abstractmethod
+  def initialize(
+    self,
+    mj_model: mujoco.MjModel,
+    model: mjwarp.Model,
+    data: mjwarp.Data,
+    device: str,
+  ) -> None:
+    """Initialize the sensor after model compilation.
+
+    This is called after the MjSpec is compiled into an MjModel and the simulation
+    is ready to run. Use this to cache sensor indices, allocate buffers, etc.
+
+    Args:
+      mj_model: The compiled MuJoCo model.
+      model: The mjwarp model wrapper.
+      data: The mjwarp data arrays.
+      device: Device for tensor operations (e.g., "cuda", "cpu").
+    """
+    raise NotImplementedError
+
+  @property
+  def data(self) -> T:
+    """Get the current sensor data, using cached value if available.
+
+    This property returns the sensor's current data in its specific type.
+    The data type is specified by the type parameter T. The data is cached
+    per-step and recomputed only when the cache is invalidated (after
+    `reset()` or `update()` is called).
+
+    Returns:
+      The sensor data in the format specified by type parameter T.
+    """
+    if not self._cache_valid:
+      self._cached_data = self._compute_data()
+      self._cache_valid = True
+    assert self._cached_data is not None
+    return self._cached_data
+
+  @abstractmethod
+  def _compute_data(self) -> T:
+    """Compute and return the sensor data.
+
+    Subclasses must implement this method to compute the sensor's data.
+    This is called by the `data` property when the cache is invalid.
+
+    Returns:
+      The computed sensor data.
+    """
+    raise NotImplementedError
+
+  def _invalidate_cache(self) -> None:
+    """Invalidate the cached data, forcing recomputation on next access."""
+    self._cache_valid = False
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    """Reset sensor state for specified environments.
+
+    Invalidates the data cache. Override in subclasses that maintain
+    internal state, but call `super().reset(env_ids)` FIRST.
+
+    Args:
+      env_ids: Environment indices to reset. If None, reset all environments.
+    """
+    del env_ids  # Unused.
+    self._invalidate_cache()
+
+  def update(self, dt: float) -> None:
+    """Update sensor state after a simulation step.
+
+    Invalidates the data cache. Override in subclasses that need
+    per-step updates, but call `super().update(dt)` FIRST.
+
+    Args:
+      dt: Time step in seconds.
+    """
+    del dt  # Unused.
+    self._invalidate_cache()
+
+  def debug_vis(self, visualizer: DebugVisualizer) -> None:
+    """Visualize sensor data for debugging.
+
+    Base implementation does nothing. Override in subclasses that support
+    debug visualization.
+
+    Args:
+      visualizer: The debug visualizer to draw to.
+    """
+    del visualizer  # Unused.
diff --git a/src/mjlab/sensor/sensor_context.py b/src/mjlab/sensor/sensor_context.py
new file mode 100644
index 0000000..f04856a
--- /dev/null
+++ b/src/mjlab/sensor/sensor_context.py
@@ -0,0 +1,389 @@
+"""Shared render context for camera and raycast sensors."""
+
+from __future__ import annotations
+
+import warnings
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
+
+import mujoco
+import mujoco_warp as mjwarp
+import torch
+import warp as wp
+
+if TYPE_CHECKING:
+  from mjlab.sensor.camera_sensor import CameraSensor
+  from mjlab.sensor.raycast_sensor import RayCastSensor
+
+
+@wp.kernel
+def _unpack_rgb_kernel(
+  packed: wp.array2d(dtype=wp.uint32),  # type: ignore[valid-type]
+  rgb: wp.array3d(dtype=wp.uint8),  # type: ignore[valid-type]
+):
+  """Unpack ABGR uint32 pixels into separate R, G, B uint8 channels."""
+  world_idx, pixel_idx = wp.tid()  # type: ignore[attr-defined]
+  val = packed[world_idx, pixel_idx]
+  b = wp.uint8(val & wp.uint32(0xFF))
+  g = wp.uint8((val >> wp.uint32(8)) & wp.uint32(0xFF))
+  r = wp.uint8((val >> wp.uint32(16)) & wp.uint32(0xFF))
+  rgb[world_idx, pixel_idx, 0] = r
+  rgb[world_idx, pixel_idx, 1] = g
+  rgb[world_idx, pixel_idx, 2] = b
+
+
+# Fields that require per-pixel ray recomputation at render time.
+_RAY_FIELDS = frozenset({"cam_fovy", "cam_intrinsic"})
+
+
+class SensorContext:
+  """Container for shared sensing resources.
+
+  Manages the RenderContext used by both camera sensors (for rendering) and raycast
+  sensors (for BVH-accelerated ray intersection). The actual graph capture and
+  execution is handled by Simulation.
+  """
+
+  def __init__(
+    self,
+    mj_model: mujoco.MjModel,
+    model: mjwarp.Model,
+    data: mjwarp.Data,
+    camera_sensors: list[CameraSensor],
+    raycast_sensors: Sequence[RayCastSensor],
+    device: str,
+  ):
+    self._model = model
+    self._data = data
+    self.wp_device = wp.get_device(device)
+
+    # Sort camera sensors by camera index for consistent ordering.
+    self.camera_sensors = sorted(camera_sensors, key=lambda s: s.camera_idx)
+    self.raycast_sensors = raycast_sensors
+
+    # MuJoCo camera ID -> sorted list index.
+    self._cam_idx_to_list_idx = {
+      s.camera_idx: idx for idx, s in enumerate(self.camera_sensors)
+    }
+
+    if self.camera_sensors:
+      self._validate_sensor_settings()
+
+    self._rgb_unpacked: wp.array | None = None
+    self._rgb_torch: torch.Tensor | None = None
+    self._depth_torch: torch.Tensor | None = None
+    self._seg_torch: torch.Tensor | None = None
+    self._rgb_adr_np: list[int] | None = None
+    self._depth_adr_np: list[int] | None = None
+    self._seg_adr_np: list[int] | None = None
+    self._disable_precomputed_rays = False
+    self._create_context(mj_model)
+
+    # Wire up sensors to use this context.
+    for sensor in self.camera_sensors:
+      sensor.set_context(self)
+    for sensor in self.raycast_sensors:
+      sensor.set_context(self)
+
+  @property
+  def has_cameras(self) -> bool:
+    return len(self.camera_sensors) > 0
+
+  @property
+  def has_raycasts(self) -> bool:
+    return len(self.raycast_sensors) > 0
+
+  @property
+  def render_context(self) -> mjwarp.RenderContext:
+    return self._ctx
+
+  def recreate(
+    self,
+    mj_model: mujoco.MjModel,
+    expanded_fields: set[str] | None = None,
+  ) -> None:
+    """Recreate the render context after model fields are expanded.
+
+    Called by Simulation.expand_model_fields() for domain randomization.
+    """
+    if expanded_fields is not None:
+      self._disable_precomputed_rays = bool(expanded_fields & _RAY_FIELDS)
+    self._create_context(mj_model)
+
+  def prepare(self) -> None:
+    """Pre-graph: transform rays to world frame."""
+    for sensor in self.raycast_sensors:
+      sensor.prepare_rays()
+
+  def finalize(self) -> None:
+    """Post-graph: compute raycast hit positions."""
+    for sensor in self.raycast_sensors:
+      sensor.postprocess_rays()
+    # Fresh render results: drop camera data cached by a pre-sense read so
+    # observations serve this step's frames (mirrors the raycast
+    # invalidation in postprocess_rays).
+    for sensor in self.camera_sensors:
+      sensor._invalidate_cache()
+
+  def get_rgb(self, cam_idx: int) -> torch.Tensor:
+    """Get unpacked RGB data for a camera.
+
+    Args:
+      cam_idx: MuJoCo camera ID.
+
+    Returns:
+      Tensor of shape [num_envs, height, width, 3] (uint8).
+    """
+    if self._rgb_unpacked is None:
+      raise RuntimeError(
+        "RGB rendering is not enabled. Ensure at least one camera sensor has 'rgb' in"
+        " its data_types."
+      )
+
+    if cam_idx not in self._cam_idx_to_list_idx:
+      available = list(self._cam_idx_to_list_idx.keys())
+      raise KeyError(
+        f"Camera ID {cam_idx} not found in SensorContext. "
+        f"Available camera IDs: {available}"
+      )
+
+    list_idx = self._cam_idx_to_list_idx[cam_idx]
+
+    assert self._rgb_adr_np is not None
+    assert self._rgb_torch is not None
+    rgb_adr = self._rgb_adr_np[list_idx]
+    if rgb_adr < 0:
+      raise RuntimeError(f"Camera ID {cam_idx} does not have RGB rendering enabled.")
+
+    sensor = self.camera_sensors[list_idx]
+    w, h = sensor.cfg.width, sensor.cfg.height
+    num_pixels = w * h
+    nworld = self._data.nworld
+
+    cam_data = self._rgb_torch[:, rgb_adr : rgb_adr + num_pixels, :]
+    return cam_data.view(nworld, h, w, 3)
+
+  def get_depth(self, cam_idx: int) -> torch.Tensor:
+    """Get depth data for a camera.
+
+    Args:
+      cam_idx: MuJoCo camera ID.
+
+    Returns:
+      Tensor of shape [num_envs, height, width, 1] (float32).
+    """
+    if cam_idx not in self._cam_idx_to_list_idx:
+      available = list(self._cam_idx_to_list_idx.keys())
+      raise KeyError(
+        f"Camera ID {cam_idx} not found in SensorContext. "
+        f"Available camera IDs: {available}"
+      )
+
+    list_idx = self._cam_idx_to_list_idx[cam_idx]
+
+    assert self._depth_adr_np is not None
+    assert self._depth_torch is not None
+    depth_adr = self._depth_adr_np[list_idx]
+    if depth_adr < 0:
+      raise RuntimeError(f"Camera ID {cam_idx} does not have depth rendering enabled.")
+
+    sensor = self.camera_sensors[list_idx]
+    w, h = sensor.cfg.width, sensor.cfg.height
+    num_pixels = w * h
+    nworld = self._data.nworld
+
+    cam_data = self._depth_torch[:, depth_adr : depth_adr + num_pixels]
+    return cam_data.view(nworld, h, w, 1)
+
+  def get_segmentation(self, cam_idx: int) -> torch.Tensor:
+    """Get per-pixel segmentation data for a camera.
+
+    Args:
+      cam_idx: MuJoCo camera ID.
+
+    Returns:
+      Tensor of shape [num_envs, height, width, 2] (int32).
+      Channel 0 stores object IDs. Channel 1 stores MuJoCo object types.
+    """
+    if cam_idx not in self._cam_idx_to_list_idx:
+      available = list(self._cam_idx_to_list_idx.keys())
+      raise KeyError(
+        f"Camera ID {cam_idx} not found in SensorContext. "
+        f"Available camera IDs: {available}"
+      )
+
+    list_idx = self._cam_idx_to_list_idx[cam_idx]
+
+    assert self._seg_adr_np is not None
+    assert self._seg_torch is not None
+    seg_adr = self._seg_adr_np[list_idx]
+    if seg_adr < 0:
+      raise RuntimeError(
+        f"Camera ID {cam_idx} does not have segmentation rendering enabled."
+      )
+
+    sensor = self.camera_sensors[list_idx]
+    w, h = sensor.cfg.width, sensor.cfg.height
+    num_pixels = w * h
+    nworld = self._data.nworld
+
+    cam_data = self._seg_torch[:, seg_adr : seg_adr + num_pixels, :]
+    return cam_data.view(nworld, h, w, 2)
+
+  # Private methods.
+
+  def _validate_sensor_settings(self) -> None:
+    """Validate that all camera sensors share render settings."""
+    ref = self.camera_sensors[0].cfg
+    for s in self.camera_sensors[1:]:
+      cfg = s.cfg
+      if cfg.use_textures != ref.use_textures:
+        raise ValueError(
+          "All camera sensors must share the same use_textures "
+          f"setting. '{s.cfg.name}' differs from "
+          f"'{ref.name}'."
+        )
+      if cfg.use_shadows != ref.use_shadows:
+        raise ValueError(
+          "All camera sensors must share the same use_shadows "
+          f"setting. '{s.cfg.name}' differs from "
+          f"'{ref.name}'."
+        )
+      if cfg.enabled_geom_groups != ref.enabled_geom_groups:
+        raise ValueError(
+          "All camera sensors must share the same "
+          f"enabled_geom_groups. '{s.cfg.name}' differs from "
+          f"'{ref.name}'."
+        )
+
+  def _raycast_geom_groups(self) -> set[int]:
+    """Compute the union of geom groups across all raycast sensors."""
+    groups: set[int] = set()
+    for s in self.raycast_sensors:
+      if s.include_geom_groups is None:
+        return {0, 1, 2, 3, 4, 5}
+      groups.update(s.include_geom_groups)
+    return groups
+
+  def _create_context(self, mj_model: mujoco.MjModel) -> None:
+    """Create the mujoco_warp RenderContext."""
+    ncam = mj_model.ncam
+    cam_res: list[tuple[int, int]] | None = None
+    render_rgb: list[bool] | None = None
+    render_depth: list[bool] | None = None
+    render_seg: list[bool] | None = None
+
+    raycast_geom_groups = self._raycast_geom_groups()
+
+    if self.camera_sensors:
+      ref_cfg = self.camera_sensors[0].cfg
+      use_textures = ref_cfg.use_textures
+      use_shadows = ref_cfg.use_shadows
+      cam_geom_groups = set(ref_cfg.enabled_geom_groups)
+
+      if self.raycast_sensors and raycast_geom_groups != cam_geom_groups:
+        merged = sorted(cam_geom_groups | raycast_geom_groups)
+        warnings.warn(
+          "Camera enabled_geom_groups "
+          f"{sorted(cam_geom_groups)} and raycast "
+          f"include_geom_groups {sorted(raycast_geom_groups)}"
+          f" differ. Using union {merged}.",
+          stacklevel=2,
+        )
+        enabled_geom_groups = merged
+      else:
+        enabled_geom_groups = sorted(cam_geom_groups)
+
+      # Build cam_active mask: only activate cameras that are sensors.
+      # cam_res, render_rgb, render_depth follow sorted sensor order (by camera_idx).
+      # This must match the order used by create_render_context for rgb_adr/depth_adr
+      # indexing.
+      cam_active = [False] * ncam
+      cam_res = []
+      render_rgb = []
+      render_depth = []
+      render_seg = []
+
+      for s in self.camera_sensors:
+        cam_active[s.camera_idx] = True
+        cam_res.append((s.cfg.width, s.cfg.height))
+        render_rgb.append("rgb" in s.cfg.data_types)
+        render_depth.append("depth" in s.cfg.data_types)
+        render_seg.append("segmentation" in s.cfg.data_types)
+    else:
+      # Raycasts-only: need BVH but no camera rendering.
+      use_textures = False
+      use_shadows = False
+      enabled_geom_groups = sorted(raycast_geom_groups)
+      cam_active = [False] * ncam
+
+    with wp.ScopedDevice(self.wp_device):
+      self._ctx = mjwarp.create_render_context(
+        mjm=mj_model,
+        nworld=self._data.nworld,
+        cam_res=cam_res,
+        render_rgb=render_rgb,
+        render_depth=render_depth,
+        use_textures=use_textures,
+        use_shadows=use_shadows,
+        enabled_geom_groups=enabled_geom_groups,
+        cam_active=cam_active,
+        use_precomputed_rays=not self._disable_precomputed_rays,
+        render_seg=render_seg,
+        render_skybox=True,
+        background_color=(0.0, 0.0, 0.0, 1.0),
+      )
+
+    # Cache address arrays from the render context. An adr value of -1 means that data
+    # type is not enabled for that camera.
+    if self.camera_sensors:
+      self._rgb_adr_np = self._ctx.rgb_adr.numpy().tolist()
+      self._depth_adr_np = self._ctx.depth_adr.numpy().tolist()
+      self._seg_adr_np = self._ctx.seg_adr.numpy().tolist()
+
+    has_any_rgb = self._rgb_adr_np is not None and any(a >= 0 for a in self._rgb_adr_np)
+    has_any_depth = self._depth_adr_np is not None and any(
+      a >= 0 for a in self._depth_adr_np
+    )
+    has_any_seg = self._seg_adr_np is not None and any(a >= 0 for a in self._seg_adr_np)
+
+    # Allocate RGB unpack buffer if any camera wants RGB.
+    if has_any_rgb:
+      total_rgb_pixels = self._ctx.rgb_data.shape[1]
+      nworld = self._data.nworld
+      self._rgb_unpacked = wp.zeros(
+        (nworld, total_rgb_pixels, 3),
+        dtype=wp.uint8,
+        device=self.wp_device,
+      )
+      self._rgb_torch = wp.to_torch(self._rgb_unpacked)
+    else:
+      self._rgb_unpacked = None
+      self._rgb_torch = None
+
+    # Cache depth torch view (zero-copy).
+    if has_any_depth:
+      self._depth_torch = wp.to_torch(self._ctx.depth_data)
+    else:
+      self._depth_torch = None
+
+    # Cache segmentation torch view (zero-copy).
+    if has_any_seg:
+      self._seg_torch = wp.to_torch(self._ctx.seg_data)
+    else:
+      self._seg_torch = None
+
+  def unpack_rgb(self) -> None:
+    """Unpack packed uint32 RGB data into separate channels.
+
+    Called from Simulation._sense_kernel() so it gets captured in the
+    CUDA graph. No-op if no cameras need RGB.
+    """
+    if self._rgb_unpacked is not None:
+      wp.launch(
+        _unpack_rgb_kernel,
+        dim=(self._data.nworld, self._ctx.rgb_data.shape[1]),
+        inputs=[self._ctx.rgb_data],
+        outputs=[self._rgb_unpacked],
+        device=self.wp_device,
+      )
diff --git a/src/mjlab/sensor/terrain_height_sensor.py b/src/mjlab/sensor/terrain_height_sensor.py
new file mode 100644
index 0000000..8e57cf3
--- /dev/null
+++ b/src/mjlab/sensor/terrain_height_sensor.py
@@ -0,0 +1,94 @@
+"""Terrain height sensor for per-frame vertical clearance."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import torch
+
+from mjlab.sensor.raycast_sensor import RayCastData, RayCastSensor, RayCastSensorCfg
+
+
+@dataclass
+class TerrainHeightData(RayCastData):
+  """Raycast data extended with per-frame terrain clearance.
+
+  Inherits all fields from :class:`RayCastData` (distances, hit positions, normals,
+  frame poses) and adds :attr:`heights`.
+  """
+
+  heights: torch.Tensor
+  """Vertical clearance per frame. Shape is ``[B, F]`` when a reduction is
+  applied, or ``[B, F, N]`` with ``reduction="none"``."""
+
+
+@dataclass
+class TerrainHeightSensorCfg(RayCastSensorCfg):
+  """RayCastSensor that reports per-frame vertical clearance above terrain.
+
+  Inherits all raycasting configuration from :class:`RayCastSensorCfg`. The sensor
+  computes ``frame_z - hit_z`` for each ray and reduces across rays per frame using
+  the chosen :attr:`reduction`.
+  """
+
+  reduction: str = "min"
+  """How to aggregate rays within each frame: ``"min"``, ``"max"``, ``"mean"``,
+  or ``"none"`` (no reduction, returns ``[B, F, N]``).
+  Defaults to ``"min"`` (closest terrain point)."""
+
+  def build(self) -> TerrainHeightSensor:
+    return TerrainHeightSensor(self)
+
+
+class TerrainHeightSensor(RayCastSensor):
+  """Per-frame vertical clearance above terrain.
+
+  Inherits all raycasting from :class:`RayCastSensor`. Access terrain heights via
+  ``sensor.data.heights`` (shape ``[B, F]``).
+  """
+
+  cfg: TerrainHeightSensorCfg
+
+  @property
+  def data(self) -> TerrainHeightData:
+    """Raycast data with per-frame terrain clearance heights."""
+    return super().data  # type: ignore[return-value]
+
+  def _compute_data(self) -> TerrainHeightData:
+    raw = super()._compute_data()
+    F, N = self.num_frames, self.num_rays_per_frame
+    B = raw.distances.shape[0]
+
+    frame_z = raw.frame_pos_w[:, :, 2]  # [B, F]
+    hit_z = raw.hit_pos_w[:, :, 2].view(B, F, N)  # [B, F, N]
+    heights = frame_z.unsqueeze(-1) - hit_z  # [B, F, N]
+
+    dists = raw.distances.view(B, F, N)
+    normal_z = raw.normals_w[:, :, 2].view(B, F, N)
+
+    # Backface hit: ray hit the underside of geometry (normal_z < 0).
+    # This means the ray origin is inside terrain, so clearance is 0.
+    backface = (dists >= 0) & (normal_z < 0)
+    heights = torch.where(backface, torch.zeros_like(heights), heights)
+
+    # True miss: no intersection at all.
+    miss = dists < 0
+    all_miss = miss.all(dim=-1, keepdim=True).expand_as(miss)  # [B, F, N]
+    fallback = frame_z.unsqueeze(-1).clamp(0, self.cfg.max_distance)
+    fallback = fallback.expand_as(heights)  # [B, F, N]
+    miss_value = torch.where(all_miss, fallback, self.cfg.max_distance)
+    heights = torch.where(miss, miss_value, heights)
+
+    reduction = self.cfg.reduction
+    if reduction == "min":
+      reduced = heights.min(dim=-1).values
+    elif reduction == "max":
+      reduced = heights.max(dim=-1).values
+    elif reduction == "mean":
+      reduced = heights.mean(dim=-1)
+    elif reduction == "none":
+      reduced = heights
+    else:
+      raise ValueError(f"Unknown reduction: {reduction!r}")
+
+    return TerrainHeightData(**vars(raw), heights=reduced)
diff --git a/src/mjlab/sim/__init__.py b/src/mjlab/sim/__init__.py
new file mode 100644
index 0000000..0329e1e
--- /dev/null
+++ b/src/mjlab/sim/__init__.py
@@ -0,0 +1,5 @@
+from mjlab.sim.sim import MujocoCfg as MujocoCfg
+from mjlab.sim.sim import Simulation as Simulation
+from mjlab.sim.sim import SimulationCfg as SimulationCfg
+from mjlab.sim.sim_data import TorchArray as TorchArray
+from mjlab.sim.sim_data import WarpBridge as WarpBridge
diff --git a/src/mjlab/sim/randomization.py b/src/mjlab/sim/randomization.py
new file mode 100644
index 0000000..7b8d74f
--- /dev/null
+++ b/src/mjlab/sim/randomization.py
@@ -0,0 +1,56 @@
+from typing import Any
+
+import mujoco_warp as mjwarp
+import warp as wp
+
+# Ref: https://github.com/newton-physics/newton/blob/640095cbe1914d43e9158ec71264a0eb7272fc15/newton/_src/solvers/mujoco/solver_mujoco.py#L2587-L2612
+
+
+@wp.kernel(module="unique")
+def repeat_array_kernel(
+  src: wp.array(dtype=Any),  # type: ignore
+  nelems_per_world: int,
+  dst: wp.array(dtype=Any),  # type: ignore
+):
+  tid = wp.tid()
+  src_idx = tid % nelems_per_world  # type: ignore[operator]
+  dst[tid] = src[src_idx]
+
+
+def expand_model_fields(
+  model: mjwarp.Model,
+  nworld: int,
+  fields_to_expand: list[str],
+) -> None:
+  if nworld == 1:
+    return
+
+  def tile(x: wp.array) -> wp.array | wp.array2d | wp.array3d | wp.array4d:
+    # Create new array with same shape but first dim multiplied by nworld.
+    new_shape = list(x.shape)
+    new_shape[0] = nworld
+    wp_array = {1: wp.array, 2: wp.array2d, 3: wp.array3d, 4: wp.array4d}[
+      len(new_shape)
+    ]
+    dst = wp_array(shape=new_shape, dtype=x.dtype, device=x.device)
+
+    src_flat = x.flatten()
+    dst_flat = dst.flatten()  # type: ignore[possibly-missing-attribute]
+
+    # Launch kernel to repeat data, one thread per destination element.
+    n_elems_per_world = dst_flat.shape[0] // nworld
+    wp.launch(
+      repeat_array_kernel,
+      dim=dst_flat.shape[0],
+      inputs=[src_flat, n_elems_per_world],
+      outputs=[dst_flat],
+      device=x.device,
+    )
+    return dst
+
+  for field in model.__dataclass_fields__:
+    if field in fields_to_expand:
+      array = getattr(model, field)
+      if array.shape[0] != 1:
+        continue  # Already per-world (e.g., variant compilation).
+      setattr(model, field, tile(array))
diff --git a/src/mjlab/sim/sim.py b/src/mjlab/sim/sim.py
new file mode 100644
index 0000000..cac627b
--- /dev/null
+++ b/src/mjlab/sim/sim.py
@@ -0,0 +1,581 @@
+from __future__ import annotations
+
+import gc
+import warnings
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Literal, cast
+
+import mujoco
+import mujoco_warp as mjwarp
+import torch
+import warp as wp
+
+from mjlab.entity.variants import VARIANT_DEPENDENT_FIELDS, build_variant_model
+from mjlab.managers.event_manager import RecomputeLevel
+from mjlab.sim.randomization import expand_model_fields
+from mjlab.sim.sim_data import TorchArray, WarpBridge
+from mjlab.utils.nan_guard import NanGuard, NanGuardCfg
+
+if TYPE_CHECKING:
+  from mjlab.entity.variants import VariantMetadata
+  from mjlab.sensor.sensor_context import SensorContext
+
+# Type aliases for better IDE support while maintaining runtime compatibility
+# At runtime, WarpBridge wraps the actual MJWarp objects.
+if TYPE_CHECKING:
+  ModelBridge = mjwarp.Model
+  DataBridge = mjwarp.Data
+else:
+  ModelBridge = WarpBridge
+  DataBridge = WarpBridge
+
+# Minimum CUDA driver version supported for conditional CUDA graphs.
+_GRAPH_CAPTURE_MIN_DRIVER = (12, 4)
+
+
+@contextmanager
+def _suspend_gc():
+  """Temporarily disable the garbage collector.
+
+  Prevents GC from finalizing stale Warp Graph objects during wp.ScopedCapture, which
+  would record their destructor calls into the new graph and corrupt it on replay.
+  """
+  enabled = gc.isenabled()
+  gc.disable()
+  try:
+    yield
+  finally:
+    if enabled:
+      gc.enable()
+
+
+_JACOBIAN_MAP = {
+  "auto": mujoco.mjtJacobian.mjJAC_AUTO,
+  "dense": mujoco.mjtJacobian.mjJAC_DENSE,
+  "sparse": mujoco.mjtJacobian.mjJAC_SPARSE,
+}
+_CONE_MAP = {
+  "elliptic": mujoco.mjtCone.mjCONE_ELLIPTIC,
+  "pyramidal": mujoco.mjtCone.mjCONE_PYRAMIDAL,
+}
+_INTEGRATOR_MAP = {
+  "euler": mujoco.mjtIntegrator.mjINT_EULER,
+  "implicitfast": mujoco.mjtIntegrator.mjINT_IMPLICITFAST,
+}
+_SOLVER_MAP = {
+  "newton": mujoco.mjtSolver.mjSOL_NEWTON,
+  "cg": mujoco.mjtSolver.mjSOL_CG,
+  "pgs": mujoco.mjtSolver.mjSOL_PGS,
+}
+_BROADPHASE_MAP = {
+  "nxn": mjwarp.BroadphaseType.NXN,
+  "sap_tile": mjwarp.BroadphaseType.SAP_TILE,
+  "sap_segmented": mjwarp.BroadphaseType.SAP_SEGMENTED,
+}
+_BROADPHASE_FILTER_MAP = {
+  "plane": mjwarp.BroadphaseFilter.PLANE,
+  "sphere": mjwarp.BroadphaseFilter.SPHERE,
+  "aabb": mjwarp.BroadphaseFilter.AABB,
+  "obb": mjwarp.BroadphaseFilter.OBB,
+}
+
+# Maps short flag names to MuJoCo enum values.
+# Names match the XML <flag> attribute names (e.g. <flag contact="disable"/>).
+_DISABLE_FLAG_MAP: dict[str, int] = {
+  name.removeprefix("mjDSBL_").lower(): getattr(mujoco.mjtDisableBit, name).value
+  for name in dir(mujoco.mjtDisableBit)
+  if name.startswith("mjDSBL_")
+}
+_ENABLE_FLAG_MAP: dict[str, int] = {
+  name.removeprefix("mjENBL_").lower(): getattr(mujoco.mjtEnableBit, name).value
+  for name in dir(mujoco.mjtEnableBit)
+  if name.startswith("mjENBL_")
+}
+
+
+@dataclass
+class MujocoCfg:
+  """Configuration for MuJoCo simulation parameters."""
+
+  # Integrator settings.
+  timestep: float = 0.002
+  integrator: Literal["euler", "implicitfast"] = "implicitfast"
+
+  # Friction settings.
+  impratio: float = 1.0
+  cone: Literal["pyramidal", "elliptic"] = "pyramidal"
+
+  # Solver settings.
+  jacobian: Literal["auto", "dense", "sparse"] = "auto"
+  solver: Literal["newton", "cg", "pgs"] = "newton"
+  iterations: int = 100
+  tolerance: float = 1e-8
+  ls_iterations: int = 50
+  ls_tolerance: float = 0.01
+  ccd_iterations: int = 50
+
+  # Other.
+  gravity: tuple[float, float, float] = (0.0, 0.0, -9.81)
+  # Global MuJoCo option flags. Names match the XML <flag> attributes
+  # (e.g. "contact", "gravity", "sensor"). See mjtDisableBit / mjtEnableBit.
+  disableflags: tuple[str, ...] = ()
+  """Disable flags to set (e.g. ``("contact",)`` to disable contacts)."""
+  enableflags: tuple[str, ...] = ()
+  """Enable flags to set (e.g. ``("energy",)`` to enable energy computation)."""
+
+  def apply(self, model: mujoco.MjModel) -> None:
+    """Apply configuration settings to a compiled MjModel."""
+    model.opt.jacobian = _JACOBIAN_MAP[self.jacobian]
+    model.opt.cone = _CONE_MAP[self.cone]
+    model.opt.integrator = _INTEGRATOR_MAP[self.integrator]
+    model.opt.solver = _SOLVER_MAP[self.solver]
+    model.opt.timestep = self.timestep
+    model.opt.impratio = self.impratio
+    model.opt.gravity[:] = self.gravity
+    model.opt.iterations = self.iterations
+    model.opt.tolerance = self.tolerance
+    model.opt.ls_iterations = self.ls_iterations
+    model.opt.ls_tolerance = self.ls_tolerance
+    model.opt.ccd_iterations = self.ccd_iterations
+    for flag in self.disableflags:
+      if flag not in _DISABLE_FLAG_MAP:
+        raise ValueError(
+          f"Unknown disable flag {flag!r}. Valid flags: {sorted(_DISABLE_FLAG_MAP)}"
+        )
+      model.opt.disableflags |= _DISABLE_FLAG_MAP[flag]
+    for flag in self.enableflags:
+      if flag not in _ENABLE_FLAG_MAP:
+        raise ValueError(
+          f"Unknown enable flag {flag!r}. Valid flags: {sorted(_ENABLE_FLAG_MAP)}"
+        )
+      model.opt.enableflags |= _ENABLE_FLAG_MAP[flag]
+
+
+@dataclass(kw_only=True)
+class SimulationCfg:
+  nconmax: int | None = None
+  """Number of contacts to allocate per world.
+
+  Contacts exist in large heterogenous arrays: one world may have more than nconmax
+  contacts. If None, a heuristic value is used."""
+  njmax: int | None = None
+  """Number of constraints to allocate per world.
+
+  Constraint arrays are batched by world: no world may have more than njmax
+  constraints. If None, a heuristic value is used."""
+  contact_sensor_maxmatch: int = 64
+  broadphase: Literal["nxn", "sap_tile", "sap_segmented"] | None = None
+  """Broadphase collision algorithm. If None, use the MuJoCo Warp default."""
+  broadphase_filter: tuple[Literal["plane", "sphere", "aabb", "obb"], ...] | None = None
+  """Bounding-volume filters applied during broadphase collision checking.
+
+  If None, use the MuJoCo Warp default."""
+  ls_parallel: bool | None = None
+  """Deprecated and ignored. Parallel linesearch was removed in MuJoCo Warp 3.10."""
+  mujoco: MujocoCfg = field(default_factory=MujocoCfg)
+  nan_guard: NanGuardCfg = field(default_factory=NanGuardCfg)
+
+  def __post_init__(self) -> None:
+    if self.ls_parallel is not None:
+      warnings.warn(
+        "SimulationCfg.ls_parallel is deprecated and ignored; parallel "
+        "linesearch was removed in MuJoCo Warp 3.10.",
+        DeprecationWarning,
+        stacklevel=2,
+      )
+
+  def apply_wp_opt(self, wp_opt: mjwarp.Option) -> None:
+    """Apply MuJoCo Warp-only settings to a warp Option (post ``put_model``)."""
+    wp_opt.contact_sensor_maxmatch = self.contact_sensor_maxmatch
+    if self.broadphase is not None:
+      wp_opt.broadphase = _BROADPHASE_MAP[self.broadphase]
+    if self.broadphase_filter is not None:
+      wp_opt.broadphase_filter = mjwarp.BroadphaseFilter(0)
+      for name in self.broadphase_filter:
+        wp_opt.broadphase_filter |= _BROADPHASE_FILTER_MAP[name]
+
+
+class Simulation:
+  """GPU-accelerated MuJoCo simulation powered by MJWarp.
+
+  CUDA Graph Capture
+  ------------------
+  On CUDA devices with memory pools enabled, the simulation captures CUDA graphs
+  for ``step()``, ``forward()``, and ``reset()`` operations. Graph capture records
+  a sequence of GPU kernels and their memory addresses, then replays the entire
+  sequence with a single kernel launch, eliminating CPU overhead from repeated
+  kernel dispatches.
+
+  **Important:** A captured graph holds pointers to the GPU arrays that existed
+  at capture time. If those arrays are later replaced (e.g., via
+  ``expand_model_fields()``), the graph will still read from the old arrays,
+  silently ignoring any new values. The ``expand_model_fields()`` method handles
+  this automatically by calling ``create_graph()`` after replacing arrays.
+
+  If you write code that replaces model or data arrays after simulation
+  initialization, you **must** call ``create_graph()`` afterward to re-capture
+  the graphs with the new memory addresses.
+  """
+
+  def __init__(
+    self,
+    num_envs: int,
+    cfg: SimulationCfg,
+    model: mujoco.MjModel | None = None,
+    device: str = "cuda:0",
+    *,
+    spec: mujoco.MjSpec | None = None,
+    variant_info: list[tuple[str, VariantMetadata]] | None = None,
+  ):
+    self.cfg = cfg
+    self.device = device
+    self.wp_device = wp.get_device(self.device)
+    self.num_envs = num_envs
+    self._default_model_fields: dict[str, torch.Tensor] = {}
+    # Fields whose DR baseline is per-world (DR's `_select_default_values`
+    # uses this to know whether to index `[env, ...]` vs `[...]`).
+    # Variant-dependent fields go here; `geom_dataid` does not, because
+    # DR does not randomize mesh selection.
+    self._per_world_default_fields: set[str] = set()
+    # Fields that have per-world warp arrays (viewer sync uses this to
+    # know what to copy per env). Superset of `_per_world_default_fields`
+    # plus `geom_dataid` for variant scenes.
+    self._expanded_fields: set[str] = set()
+    # Per-entity variant assignment, keyed by entity name (no trailing
+    # slash). Empty for non-variant scenes.
+    self._world_to_variant: dict[str, torch.Tensor] = {}
+
+    if spec is not None and variant_info:
+      self._init_with_variants(spec, variant_info)
+    elif spec is not None:
+      compiled = spec.compile()
+      cfg.mujoco.apply(compiled)
+      self._init_with_model(compiled)
+    elif model is not None:
+      cfg.mujoco.apply(model)
+      self._init_with_model(model)
+    else:
+      raise ValueError("Either model or spec must be provided.")
+
+  def _init_with_model(self, model: mujoco.MjModel) -> None:
+    """Standard path: build warp model from compiled MjModel."""
+    self._mj_model = model
+    self._mj_data = mujoco.MjData(model)
+    mujoco.mj_forward(self._mj_model, self._mj_data)
+
+    with wp.ScopedDevice(self.wp_device):
+      self._wp_model = mjwarp.put_model(self._mj_model)
+      self.cfg.apply_wp_opt(self._wp_model.opt)
+      self._finish_init()
+
+  def _init_with_variants(
+    self,
+    spec: mujoco.MjSpec,
+    variant_info: list[tuple[str, VariantMetadata]],
+  ) -> None:
+    """Per-world mesh path: build model with per-world geom_dataid.
+
+    ``self._mj_model`` remains a single host-side template model. The actual
+    simulation model may store variant-dependent fields as per-world arrays in
+    ``self._wp_model`` / ``self.model``. CPU consumers that call MuJoCo APIs on
+    ``self._mj_model`` must first sync the relevant per-world fields for the env
+    they are rendering or inspecting.
+    """
+    with wp.ScopedDevice(self.wp_device):
+      result = build_variant_model(
+        spec,
+        self.num_envs,
+        variant_info,
+        configure_model=self.cfg.mujoco.apply,
+      )
+      self._mj_model = result.mj_model
+      self._mj_data = mujoco.MjData(self._mj_model)
+      mujoco.mj_forward(self._mj_model, self._mj_data)
+
+      self._wp_model = result.wp_model
+      self.cfg.apply_wp_opt(self._wp_model.opt)
+
+      # Snapshot variant-dependent fields as per-world defaults so
+      # DR scale/add operations use each variant's base values.
+      for field_name in VARIANT_DEPENDENT_FIELDS:
+        arr = getattr(self._wp_model, field_name)
+        self._default_model_fields[field_name] = torch.as_tensor(
+          arr.numpy(), device=self.device
+        ).clone()
+      self._per_world_default_fields.update(VARIANT_DEPENDENT_FIELDS)
+
+      self._finish_init()
+
+    # Register variant-dependent fields as expanded so the native
+    # viewer syncs them per-world.
+    self._expanded_fields.update(VARIANT_DEPENDENT_FIELDS)
+    self._expanded_fields.add("geom_dataid")
+    self._expanded_fields.add("geom_matid")
+
+    # Stash variant assignments as torch tensors keyed by bare entity name
+    # (build_variant_model emits "<name>/" prefixes; strip the trailing slash for
+    # the public API).
+    for prefix, arr in result.world_to_variant.items():
+      key = prefix.rstrip("/")
+      self._world_to_variant[key] = torch.as_tensor(
+        arr, dtype=torch.long, device=self.device
+      )
+
+  def _finish_init(self) -> None:
+    """Common initialization after warp model is created."""
+    self._wp_data = mjwarp.put_data(
+      self._mj_model,
+      self._mj_data,
+      nworld=self.num_envs,
+      nconmax=self.cfg.nconmax,
+      njmax=self.cfg.njmax,
+    )
+
+    self._reset_mask_wp = wp.zeros(self.num_envs, dtype=bool)
+    self._reset_mask = TorchArray(self._reset_mask_wp)
+
+    self._model_bridge = WarpBridge(self._wp_model, nworld=self.num_envs)
+    self._data_bridge = WarpBridge(self._wp_data)
+    self._sensor_context: SensorContext | None = None
+
+    self.use_cuda_graph = self._should_use_cuda_graph()
+    self.create_graph()
+
+    self.nan_guard = NanGuard(self.cfg.nan_guard, self.num_envs, self._mj_model)
+
+  def create_graph(self) -> None:
+    """Capture CUDA graphs for step, forward, and reset operations.
+
+    This method must be called whenever GPU arrays in the model or data are
+    replaced after initialization. The captured graphs hold pointers to the
+    arrays that existed at capture time. If those arrays are replaced, the
+    graphs will silently read from the old arrays, ignoring any new values.
+
+    Called automatically by:
+    - ``__init__()`` during simulation initialization
+    - ``expand_model_fields()`` after replacing model arrays
+
+    On CPU devices or when memory pools are disabled, this is a no-op.
+    """
+    self.step_graph = None
+    self.forward_graph = None
+    self.reset_graph = None
+    self.sense_graph = None
+    if self.use_cuda_graph:
+      with _suspend_gc(), wp.ScopedDevice(self.wp_device):
+        with wp.ScopedCapture() as capture:
+          mjwarp.step(self.wp_model, self.wp_data)
+        self.step_graph = capture.graph
+        with wp.ScopedCapture() as capture:
+          mjwarp.forward(self.wp_model, self.wp_data)
+        self.forward_graph = capture.graph
+        with wp.ScopedCapture() as capture:
+          mjwarp.reset_data(self.wp_model, self.wp_data, reset=self._reset_mask_wp)
+        self.reset_graph = capture.graph
+        if self._sensor_context is not None:
+          with wp.ScopedCapture() as capture:
+            self._sense_kernel()
+          self.sense_graph = capture.graph
+
+  # Properties.
+
+  @property
+  def mj_model(self) -> mujoco.MjModel:
+    return self._mj_model
+
+  @property
+  def mj_data(self) -> mujoco.MjData:
+    return self._mj_data
+
+  @property
+  def wp_model(self) -> mjwarp.Model:
+    return self._wp_model
+
+  @property
+  def wp_data(self) -> mjwarp.Data:
+    return self._wp_data
+
+  @property
+  def data(self) -> "DataBridge":
+    return cast("DataBridge", self._data_bridge)
+
+  @property
+  def model(self) -> "ModelBridge":
+    return cast("ModelBridge", self._model_bridge)
+
+  @property
+  def default_model_fields(self) -> dict[str, torch.Tensor]:
+    """Default values for expanded model fields, used in domain randomization."""
+    return self._default_model_fields
+
+  @property
+  def expanded_fields(self) -> set[str]:
+    """Names of model fields that have been expanded for per-env DR."""
+    return self._expanded_fields
+
+  @property
+  def per_world_default_fields(self) -> set[str]:
+    """Fields with per-world defaults from mesh variant compilation."""
+    return self._per_world_default_fields
+
+  @property
+  def world_to_variant(self) -> dict[str, torch.Tensor]:
+    """Per-entity variant assignment for variant scenes.
+
+    Maps entity name (without trailing slash) to a ``(num_envs,)`` tensor of
+    variant indices. The index order matches the order of variants declared
+    in the entity's :class:`VariantEntityCfg`. Empty for non-variant scenes.
+    """
+    return self._world_to_variant
+
+  # Methods.
+
+  def expand_model_fields(self, fields: tuple[str, ...]) -> None:
+    """Expand model fields to support per-environment parameters."""
+    if not fields:
+      return
+
+    invalid_fields = [f for f in fields if not hasattr(self._mj_model, f)]
+    if invalid_fields:
+      raise ValueError(f"Fields not found in model: {invalid_fields}")
+
+    expand_model_fields(self._wp_model, self.num_envs, list(fields))
+    self._expanded_fields.update(fields)
+    self._model_bridge.clear_cache()
+
+    if self._sensor_context is not None:
+      self._sensor_context.recreate(self._mj_model, self._expanded_fields)
+
+    # Field expansion allocates new arrays and replaces them via setattr. The
+    # CUDA graph captured the old memory addresses, so we must recreate it.
+    self.create_graph()
+
+  def get_default_field(self, field: str) -> torch.Tensor:
+    """Get the default value for a model field, caching for reuse.
+
+    Returns the original values from the C MuJoCo model (mj_model), obtained
+    from the final compiled scene spec before any randomization is applied.
+    Not to be confused with the GPU Warp model (wp_model) which may have
+    randomized values.
+    """
+    if field not in self._default_model_fields:
+      if not hasattr(self._mj_model, field):
+        raise ValueError(f"Field '{field}' not found in model")
+      model_field = getattr(self.model, field)
+      default_value = getattr(self._mj_model, field)
+      self._default_model_fields[field] = torch.as_tensor(
+        default_value, dtype=model_field.dtype, device=self.device
+      ).clone()
+    return self._default_model_fields[field]
+
+  def recompute_constants(self, level: RecomputeLevel) -> None:
+    """Recompute derived model constants after domain randomization.
+
+    Args:
+      level: Which constants to recompute. ``set_const`` is the most
+        expensive (covers body_mass changes), ``set_const_0`` covers
+        qpos0/body_inertia/dof_armature changes, and ``set_const_fixed``
+        is the cheapest (covers body_gravcomp changes).
+    """
+    fn = getattr(mjwarp, level.name)
+    with wp.ScopedDevice(self.wp_device):
+      fn(self._wp_model, self._wp_data)
+
+  def forward(self) -> None:
+    with wp.ScopedDevice(self.wp_device):
+      if self.use_cuda_graph and self.forward_graph is not None:
+        wp.capture_launch(self.forward_graph)
+      else:
+        mjwarp.forward(self.wp_model, self.wp_data)
+
+  def step(self) -> None:
+    with wp.ScopedDevice(self.wp_device):
+      with self.nan_guard.watch(self.data):
+        if self.use_cuda_graph and self.step_graph is not None:
+          wp.capture_launch(self.step_graph)
+        else:
+          mjwarp.step(self.wp_model, self.wp_data)
+
+  def reset(self, env_ids: torch.Tensor | None = None) -> None:
+    with wp.ScopedDevice(self.wp_device):
+      if env_ids is None:
+        self._reset_mask.fill_(True)
+      else:
+        self._reset_mask.fill_(False)
+        self._reset_mask[env_ids] = True
+
+      if self.use_cuda_graph and self.reset_graph is not None:
+        wp.capture_launch(self.reset_graph)
+      else:
+        mjwarp.reset_data(self.wp_model, self.wp_data, reset=self._reset_mask_wp)
+
+  def set_sensor_context(self, ctx: SensorContext) -> None:
+    """Wire a SensorContext for camera/raycast sensing.
+
+    Automatically re-captures CUDA graphs so the sense_graph includes
+    the new sensor kernels.
+    """
+    self._sensor_context = ctx
+    self.create_graph()
+
+  def sense(self) -> None:
+    """Execute the sense pipeline: prepare -> graph -> finalize.
+
+    Runs BVH refit, camera rendering, and raycasting in a single
+    CUDA graph launch. Should be called once per env step, right
+    before observation computation.
+    """
+    if self._sensor_context is None:
+      return
+
+    ctx = self._sensor_context
+    ctx.prepare()
+
+    with wp.ScopedDevice(self.wp_device):
+      if self.use_cuda_graph and self.sense_graph is not None:
+        wp.capture_launch(self.sense_graph)
+      else:
+        self._sense_kernel()
+
+    ctx.finalize()
+
+  # Private methods.
+
+  def _sense_kernel(self) -> None:
+    """GPU kernel sequence for sensing (captured in sense_graph)."""
+    assert self._sensor_context is not None
+    ctx = self._sensor_context
+    rc = ctx.render_context
+
+    mjwarp.refit_bvh(self.wp_model, self.wp_data, rc)
+
+    if ctx.has_cameras:
+      mjwarp.render(self.wp_model, self.wp_data, rc)
+      ctx.unpack_rgb()
+
+    for sensor in ctx.raycast_sensors:
+      sensor.raycast_kernel(rc=rc)
+
+  def _should_use_cuda_graph(self) -> bool:
+    """Determine if CUDA graphs can be used based on device and driver version."""
+    if not self.wp_device.is_cuda:
+      return False
+
+    driver_ver = wp.get_cuda_driver_version()
+    has_mempool = wp.is_mempool_enabled(self.wp_device)
+
+    if driver_ver is None:
+      print("[WARNING] CUDA Graphs disabled: driver version unavailable")
+      return False
+
+    if has_mempool and driver_ver >= _GRAPH_CAPTURE_MIN_DRIVER:
+      return True
+
+    reasons = []
+    if not has_mempool:
+      reasons.append("mempool disabled")
+    if driver_ver < _GRAPH_CAPTURE_MIN_DRIVER:
+      reasons.append(f"driver {driver_ver[0]}.{driver_ver[1]} < 12.4")
+    print(f"[WARNING] CUDA Graphs disabled: {', '.join(reasons)}")
+    return False
diff --git a/src/mjlab/sim/sim_data.py b/src/mjlab/sim/sim_data.py
new file mode 100644
index 0000000..f7be2a8
--- /dev/null
+++ b/src/mjlab/sim/sim_data.py
@@ -0,0 +1,246 @@
+"""Bridge for seamless PyTorch-Warp interoperability with zero-copy memory sharing.
+
+Provides automatic wrapping of Warp arrays as PyTorch-compatible objects while
+preserving shared memory and CUDA graph compatibility.
+"""
+
+from typing import Any, Dict, Generic, Optional, Tuple, TypeVar
+
+import torch
+import warp as wp
+
+T = TypeVar("T")
+
+
+class TorchArray:
+  """Warp array that behaves like a torch.Tensor with shared memory."""
+
+  def __init__(self, wp_array: wp.array, nworld: int | None = None) -> None:
+    """Initialize the tensor proxy with a Warp array."""
+    self._wp_array = wp_array
+    # Workaround for Warp bug: wp.to_torch fails on empty CPU arrays.
+    if wp_array.device.is_cpu and wp_array.size == 0:  # type: ignore[union-attr]
+      self._tensor = torch.zeros(
+        wp_array.shape, dtype=wp.dtype_to_torch(wp_array.dtype)
+      )
+    else:
+      self._tensor = wp.to_torch(wp_array)
+
+    if (
+      nworld is not None
+      and nworld > 1
+      and len(self._tensor.shape) > 0
+      and self._tensor.shape[0] == 1
+      and (self._tensor.stride(0) == 0 or getattr(wp_array, "_is_batched", False))
+    ):
+      new_shape = (nworld,) + self._tensor.shape[1:]
+      self._tensor = self._tensor.expand(new_shape)
+
+    self._is_cuda = not self._wp_array.device.is_cpu  # type: ignore
+    self._torch_stream = self._setup_stream()
+
+  def _setup_stream(self) -> Optional[torch.cuda.Stream]:
+    """Setup appropriate stream for the device."""
+    if not self._is_cuda:
+      return None
+
+    try:
+      warp_stream = wp.get_stream(self._wp_array.device)
+      return torch.cuda.ExternalStream(warp_stream.cuda_stream)
+    except Exception as e:
+      # Fallback to default stream if external stream creation fails.
+      print(f"Warning: Could not create external stream: {e}")
+      return torch.cuda.current_stream(self._tensor.device)
+
+  @property
+  def wp_array(self) -> wp.array:
+    return self._wp_array
+
+  def __repr__(self) -> str:
+    """Return string representation of the underlying tensor."""
+    return repr(self._tensor)
+
+  def __getitem__(self, idx: Any) -> Any:
+    """Get item(s) from the tensor using standard indexing."""
+    return self._tensor[idx]
+
+  def __setitem__(self, idx: Any, value: Any) -> None:
+    """Set item(s) in the tensor using standard indexing."""
+    if self._is_cuda and self._torch_stream is not None:
+      with torch.cuda.stream(self._torch_stream):
+        self._tensor[idx] = value
+    else:
+      self._tensor[idx] = value
+
+  def __getattr__(self, name: str) -> Any:
+    """Delegate attribute access to the underlying tensor."""
+    return getattr(self._tensor, name)
+
+  @classmethod
+  def __torch_function__(
+    cls,
+    func: Any,
+    types: Tuple[type, ...],
+    args: Tuple[Any, ...] = (),
+    kwargs: Optional[Dict[str, Any]] = None,
+  ) -> Any:
+    """Intercept torch.* function calls to unwrap TorchArray objects."""
+    if kwargs is None:
+      kwargs = {}
+
+    # Only intercept when at least one argument is our proxy.
+    if not any(issubclass(t, cls) for t in types):
+      return NotImplemented
+
+    def _unwrap(x: Any) -> Any:
+      """Unwrap TorchArray objects to their underlying tensors."""
+      return x._tensor if isinstance(x, cls) else x
+
+    # Unwrap all TorchArray objects in args and kwargs.
+    unwrapped_args = tuple(_unwrap(arg) for arg in args)
+    unwrapped_kwargs = {k: _unwrap(v) for k, v in kwargs.items()}
+
+    return func(*unwrapped_args, **unwrapped_kwargs)
+
+  # Arithmetic operators.
+
+  def __add__(self, other: Any) -> Any:
+    return self._tensor + other
+
+  def __radd__(self, other: Any) -> Any:
+    return other + self._tensor
+
+  def __sub__(self, other: Any) -> Any:
+    return self._tensor - other
+
+  def __rsub__(self, other: Any) -> Any:
+    return other - self._tensor
+
+  def __mul__(self, other: Any) -> Any:
+    return self._tensor * other
+
+  def __rmul__(self, other: Any) -> Any:
+    return other * self._tensor
+
+  def __truediv__(self, other: Any) -> Any:
+    return self._tensor / other
+
+  def __rtruediv__(self, other: Any) -> Any:
+    return other / self._tensor
+
+  def __pow__(self, other: Any) -> Any:
+    return self._tensor**other
+
+  def __rpow__(self, other: Any) -> Any:
+    return other**self._tensor
+
+  def __neg__(self) -> Any:
+    return -self._tensor
+
+  def __pos__(self) -> Any:
+    return +self._tensor
+
+  def __abs__(self) -> Any:
+    return abs(self._tensor)
+
+  # Comparison operators.
+
+  def __eq__(self, other: Any) -> Any:
+    return self._tensor == other
+
+  def __ne__(self, other: Any) -> Any:
+    return self._tensor != other
+
+  def __lt__(self, other: Any) -> Any:
+    return self._tensor < other
+
+  def __le__(self, other: Any) -> Any:
+    return self._tensor <= other
+
+  def __gt__(self, other: Any) -> Any:
+    return self._tensor > other
+
+  def __ge__(self, other: Any) -> Any:
+    return self._tensor >= other
+
+
+def _contains_warp_arrays(obj: Any) -> bool:
+  """Check if an object or its attributes contain any Warp arrays."""
+  if isinstance(obj, wp.array):
+    return True
+
+  # Check if it's a struct-like object with attributes
+  if hasattr(obj, "__dict__"):
+    return any(
+      isinstance(getattr(obj, attr), wp.array)
+      for attr in dir(obj)
+      if not attr.startswith("_")
+    )
+
+  return False
+
+
+class WarpBridge(Generic[T]):
+  """Wraps mjwarp objects to expose Warp arrays as PyTorch tensors.
+
+  Automatically converts Warp array attributes to TorchArray objects
+  on access, enabling direct PyTorch operations on simulation data.
+  Recursively wraps nested structures that contain Warp arrays.
+
+  IMPORTANT: This wrapper is read-only. To modify array data, use
+  in-place operations like `obj.field[:] = value`. Direct assignment
+  like `obj.field = new_array` will raise an AttributeError to prevent
+  accidental memory address changes that break CUDA graphs.
+  """
+
+  def __init__(self, struct: T, nworld: int | None = None) -> None:
+    object.__setattr__(self, "_struct", struct)
+    object.__setattr__(self, "_wrapped_cache", {})
+    object.__setattr__(self, "_nworld", nworld)
+
+  def __getattr__(self, name: str) -> Any:
+    """Get attribute from the wrapped data, wrapping Warp arrays as TorchArray."""
+    # Check cache first to avoid recreating wrappers.
+    if name in self._wrapped_cache:
+      return self._wrapped_cache[name]
+
+    val = getattr(self._struct, name)
+
+    # Wrap Warp arrays.
+    if isinstance(val, wp.array):
+      wrapped = TorchArray(val, nworld=self._nworld)
+      self._wrapped_cache[name] = wrapped
+      return wrapped
+
+    # Recursively wrap nested structures that contain Warp arrays.
+    if _contains_warp_arrays(val):
+      wrapped = WarpBridge(val, nworld=self._nworld)
+      self._wrapped_cache[name] = wrapped
+      return wrapped
+
+    return val
+
+  def __setattr__(self, name: str, value: Any) -> None:
+    """Prevent attribute setting to maintain CUDA graph safety."""
+    raise AttributeError(
+      f"Cannot set attribute '{name}' on WarpBridge. "
+      f"This wrapper is read-only to preserve memory addresses for CUDA graphs. "
+      f"Use in-place operations instead: obj.{name}[:] = value"
+    )
+
+  def __repr__(self) -> str:
+    """Return string representation of the wrapped struct."""
+    return f"WarpBridge({repr(self._struct)})"
+
+  @property
+  def struct(self) -> T:
+    """Access the underlying wrapped struct."""
+    return self._struct
+
+  def clear_cache(self) -> None:
+    """Clear the wrapped cache to force re-wrapping of arrays.
+
+    This should be called after operations that modify the underlying warp arrays,
+    such as expand_model_fields(), to ensure the cache reflects the updated arrays.
+    """
+    object.__setattr__(self, "_wrapped_cache", {})
diff --git a/src/mjlab/tasks/__init__.py b/src/mjlab/tasks/__init__.py
new file mode 100644
index 0000000..26c873b
--- /dev/null
+++ b/src/mjlab/tasks/__init__.py
@@ -0,0 +1,5 @@
+from mjlab.utils.lab_api.tasks.importer import import_packages
+
+_BLACKLIST_PKGS = ["utils", ".mdp"]
+
+import_packages(__name__, _BLACKLIST_PKGS)
diff --git a/src/mjlab/tasks/cartpole/__init__.py b/src/mjlab/tasks/cartpole/__init__.py
new file mode 100644
index 0000000..4b03e98
--- /dev/null
+++ b/src/mjlab/tasks/cartpole/__init__.py
@@ -0,0 +1,20 @@
+from mjlab.tasks.cartpole.cartpole_env_cfg import (
+  cartpole_balance_env_cfg,
+  cartpole_ppo_runner_cfg,
+  cartpole_swingup_env_cfg,
+)
+from mjlab.tasks.registry import register_mjlab_task
+
+register_mjlab_task(
+  task_id="Mjlab-Cartpole-Balance",
+  env_cfg=cartpole_balance_env_cfg(),
+  play_env_cfg=cartpole_balance_env_cfg(play=True),
+  rl_cfg=cartpole_ppo_runner_cfg(),
+)
+
+register_mjlab_task(
+  task_id="Mjlab-Cartpole-Swingup",
+  env_cfg=cartpole_swingup_env_cfg(),
+  play_env_cfg=cartpole_swingup_env_cfg(play=True),
+  rl_cfg=cartpole_ppo_runner_cfg(),
+)
diff --git a/src/mjlab/tasks/cartpole/cartpole.xml b/src/mjlab/tasks/cartpole/cartpole.xml
new file mode 100644
index 0000000..939176e
--- /dev/null
+++ b/src/mjlab/tasks/cartpole/cartpole.xml
@@ -0,0 +1,37 @@
+<mujoco model="cartpole">
+  <default>
+    <default class="pole">
+      <joint type="hinge" axis="0 1 0" damping="2e-6"/>
+      <geom type="capsule" fromto="0 0 0 0 0 1" size="0.045" material="pole" mass=".1"/>
+    </default>
+  </default>
+
+  <asset>
+    <texture name="grid" type="2d" builtin="checker" rgb1=".1 .2 .3" rgb2=".2 .3 .4" width="300" height="300"/>
+    <material name="grid" texture="grid" texrepeat="8 8" reflectance=".2"/>
+    <material name="cart" rgba=".7 .1 .1 1"/>
+    <material name="pole" rgba=".1 .5 .8 1"/>
+    <material name="decoration" rgba=".3 .3 .3 1"/>
+  </asset>
+
+  <worldbody>
+    <light name="light" pos="0 0 6"/>
+    <camera name="fixed" pos="0 -4 1" zaxis="0 -1 0"/>
+    <camera name="lookatcart" mode="targetbody" target="cart" pos="0 -2 2"/>
+    <geom name="floor" pos="0 0 -.05" size="4 4 .2" type="plane" material="grid"/>
+    <geom name="rail1" type="capsule" pos="0 .07 1" zaxis="1 0 0" size="0.02 2" material="decoration"/>
+    <geom name="rail2" type="capsule" pos="0 -.07 1" zaxis="1 0 0" size="0.02 2" material="decoration"/>
+    <body name="cart" pos="0 0 1">
+      <joint name="slider" type="slide" limited="true" axis="1 0 0" range="-1.8 1.8" solreflimit=".08 1" damping="5e-4"/>
+      <geom name="cart" type="box" size="0.2 0.15 0.1" material="cart" mass="1"/>
+      <body name="pole_1" childclass="pole">
+        <joint name="hinge_1"/>
+        <geom name="pole_1"/>
+      </body>
+    </body>
+  </worldbody>
+
+  <actuator>
+    <motor name="slide" joint="slider" gear="10" ctrllimited="true" ctrlrange="-1 1"/>
+  </actuator>
+</mujoco>
diff --git a/src/mjlab/tasks/cartpole/cartpole_env_cfg.py b/src/mjlab/tasks/cartpole/cartpole_env_cfg.py
new file mode 100644
index 0000000..b0064c3
--- /dev/null
+++ b/src/mjlab/tasks/cartpole/cartpole_env_cfg.py
@@ -0,0 +1,309 @@
+"""Cartpole balance and swingup environment configuration."""
+
+from __future__ import annotations
+
+import math
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import mujoco
+import torch
+
+from mjlab.actuator.xml_actuator import XmlActuatorCfg
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.envs import ManagerBasedRlEnvCfg
+from mjlab.envs.mdp import (
+  joint_pos_rel,
+  joint_vel_rel,
+  reset_joints_by_offset,
+  time_out,
+)
+from mjlab.envs.mdp.actions import JointEffortActionCfg
+from mjlab.managers.action_manager import ActionTermCfg
+from mjlab.managers.event_manager import EventTermCfg
+from mjlab.managers.observation_manager import (
+  ObservationGroupCfg,
+  ObservationTermCfg,
+)
+from mjlab.managers.reward_manager import RewardTermCfg
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.managers.termination_manager import TerminationTermCfg
+from mjlab.rl import (
+  RslRlModelCfg,
+  RslRlOnPolicyRunnerCfg,
+  RslRlPpoAlgorithmCfg,
+)
+from mjlab.scene import SceneCfg
+from mjlab.sim import MujocoCfg, SimulationCfg
+from mjlab.terrains import TerrainEntityCfg
+from mjlab.viewer import ViewerConfig
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+_CARTPOLE_XML: Path = Path(__file__).parent / "cartpole.xml"
+_CART_CFG = SceneEntityCfg("cartpole", joint_names=("slider",))
+_HINGE_CFG = SceneEntityCfg("cartpole", joint_names=("hinge_1",))
+
+# Entity.
+
+
+def _get_spec() -> mujoco.MjSpec:
+  return mujoco.MjSpec.from_file(str(_CARTPOLE_XML))
+
+
+_CARTPOLE_ARTICULATION = EntityArticulationInfoCfg(
+  actuators=(XmlActuatorCfg(target_names_expr=("slider",)),),
+)
+
+_BALANCE_INIT = EntityCfg.InitialStateCfg(
+  pos=(0.0, 0.0, 0.0),
+  joint_pos={"slider": 0.0, "hinge_1": 0.0},
+  joint_vel={".*": 0.0},
+)
+
+_SWINGUP_INIT = EntityCfg.InitialStateCfg(
+  pos=(0.0, 0.0, 0.0),
+  joint_pos={"slider": 0.0, "hinge_1": math.pi},
+  joint_vel={".*": 0.0},
+)
+
+
+def _get_cartpole_cfg(swing_up: bool = False) -> EntityCfg:
+  return EntityCfg(
+    spec_fn=_get_spec,
+    articulation=_CARTPOLE_ARTICULATION,
+    init_state=_SWINGUP_INIT if swing_up else _BALANCE_INIT,
+  )
+
+
+# Observations.
+
+
+def pole_angle_cos_sin(
+  env: ManagerBasedRlEnv,
+  asset_cfg: SceneEntityCfg = _HINGE_CFG,
+) -> torch.Tensor:
+  """Cosine and sine of the pole hinge angle. Shape: [num_envs, 2]."""
+  asset: Entity = env.scene[asset_cfg.name]
+  angle = asset.data.joint_pos[:, asset_cfg.joint_ids]
+  return torch.cat([torch.cos(angle), torch.sin(angle)], dim=-1)
+
+
+# Rewards.
+
+# dm_control uses value_at_margin=0.1 by default.
+_GAUSSIAN_SCALE = math.sqrt(-2 * math.log(0.1))
+_QUADRATIC_SCALE = math.sqrt(1 - 0.1)
+
+
+def _gaussian_tolerance(x: torch.Tensor, margin: float) -> torch.Tensor:
+  """Gaussian sigmoid tolerance: 1 at x=0, value_at_margin=0.1 at |x|=margin."""
+  if margin == 0:
+    return (x == 0).float()
+  scaled = x / margin * _GAUSSIAN_SCALE
+  return torch.exp(-0.5 * scaled**2)
+
+
+def _quadratic_tolerance(x: torch.Tensor, margin: float) -> torch.Tensor:
+  """Quadratic sigmoid tolerance: 1 at x=0, 0 at |x|>=margin."""
+  if margin == 0:
+    return (x == 0).float()
+  scaled = x / margin * _QUADRATIC_SCALE
+  return torch.clamp(1 - scaled**2, min=0.0)
+
+
+def cartpole_smooth_reward(
+  env: ManagerBasedRlEnv,
+  cart_cfg: SceneEntityCfg = _CART_CFG,
+  hinge_cfg: SceneEntityCfg = _HINGE_CFG,
+) -> torch.Tensor:
+  """dm_control smooth cartpole reward: upright * centered * small_control * small_vel.
+
+  Args:
+    env: The environment.
+    cart_cfg: Entity config selecting the slider joint.
+    hinge_cfg: Entity config selecting the hinge joint.
+  """
+  asset: Entity = env.scene[cart_cfg.name]
+
+  # Pole angle cosine.
+  hinge_angle = asset.data.joint_pos[:, hinge_cfg.joint_ids].squeeze(-1)
+  pole_cos = torch.cos(hinge_angle)
+  upright = (pole_cos + 1) / 2
+
+  # Cart position.
+  cart_pos = asset.data.joint_pos[:, cart_cfg.joint_ids].squeeze(-1)
+  centered = (1 + _gaussian_tolerance(cart_pos, margin=2.0)) / 2
+
+  # Control effort (raw action from the policy).
+  control = env.action_manager.action.squeeze(-1)
+  small_control = (4 + _quadratic_tolerance(control, margin=1.0)) / 5
+
+  # Pole angular velocity.
+  hinge_vel = asset.data.joint_vel[:, hinge_cfg.joint_ids].squeeze(-1)
+  small_velocity = (1 + _gaussian_tolerance(hinge_vel, margin=5.0)) / 2
+
+  return upright * centered * small_control * small_velocity
+
+
+# Environment config.
+
+
+def _make_env_cfg(swing_up: bool = False) -> ManagerBasedRlEnvCfg:
+  cart_cfg = SceneEntityCfg("cartpole", joint_names=("slider",))
+  hinge_cfg = SceneEntityCfg("cartpole", joint_names=("hinge_1",))
+
+  actor_terms = {
+    "cart_pos": ObservationTermCfg(
+      func=joint_pos_rel,
+      params={"asset_cfg": cart_cfg},
+    ),
+    "pole_angle": ObservationTermCfg(
+      func=pole_angle_cos_sin,
+      params={"asset_cfg": hinge_cfg},
+    ),
+    "cart_vel": ObservationTermCfg(
+      func=joint_vel_rel,
+      params={"asset_cfg": cart_cfg},
+    ),
+    "pole_vel": ObservationTermCfg(
+      func=joint_vel_rel,
+      params={"asset_cfg": hinge_cfg},
+    ),
+  }
+
+  observations = {
+    "actor": ObservationGroupCfg(actor_terms, enable_corruption=True),
+    "critic": ObservationGroupCfg({**actor_terms}),
+  }
+
+  actions: dict[str, ActionTermCfg] = {
+    "effort": JointEffortActionCfg(
+      entity_name="cartpole",
+      actuator_names=("slider",),
+      scale=1.0,
+    ),
+  }
+
+  slider_range = (-0.1, 0.1) if not swing_up else (0.0, 0.0)
+  events = {
+    "reset_slider": EventTermCfg(
+      func=reset_joints_by_offset,
+      mode="reset",
+      params={
+        "position_range": slider_range,
+        "velocity_range": (-0.01, 0.01),
+        "asset_cfg": SceneEntityCfg("cartpole", joint_names=("slider",)),
+      },
+    ),
+    "reset_hinge": EventTermCfg(
+      func=reset_joints_by_offset,
+      mode="reset",
+      params={
+        "position_range": (-0.034, 0.034),
+        "velocity_range": (-0.01, 0.01),
+        "asset_cfg": SceneEntityCfg("cartpole", joint_names=("hinge_1",)),
+      },
+    ),
+  }
+
+  rewards = {
+    "smooth_reward": RewardTermCfg(
+      func=cartpole_smooth_reward,
+      weight=1.0,
+      params={"cart_cfg": cart_cfg, "hinge_cfg": hinge_cfg},
+    ),
+  }
+
+  terminations = {
+    "time_out": TerminationTermCfg(func=time_out, time_out=True),
+  }
+
+  return ManagerBasedRlEnvCfg(
+    scene=SceneCfg(
+      terrain=TerrainEntityCfg(terrain_type="plane"),
+      entities={"cartpole": _get_cartpole_cfg(swing_up=swing_up)},
+      num_envs=1,
+      env_spacing=4.0,
+    ),
+    observations=observations,
+    actions=actions,
+    events=events,
+    rewards=rewards,
+    terminations=terminations,
+    viewer=ViewerConfig(
+      origin_type=ViewerConfig.OriginType.ASSET_BODY,
+      entity_name="cartpole",
+      body_name="cart",
+      distance=4.0,
+      elevation=-15.0,
+      azimuth=0.0,
+    ),
+    sim=SimulationCfg(
+      mujoco=MujocoCfg(timestep=0.01, disableflags=("contact",)),
+    ),
+    decimation=5,
+    episode_length_s=50.0,
+  )
+
+
+def cartpole_balance_env_cfg(
+  play: bool = False,
+) -> ManagerBasedRlEnvCfg:
+  cfg = _make_env_cfg(swing_up=False)
+  if play:
+    cfg.episode_length_s = 1e10
+    cfg.observations["actor"].enable_corruption = False
+  return cfg
+
+
+def cartpole_swingup_env_cfg(
+  play: bool = False,
+) -> ManagerBasedRlEnvCfg:
+  cfg = _make_env_cfg(swing_up=True)
+  if play:
+    cfg.episode_length_s = 1e10
+    cfg.observations["actor"].enable_corruption = False
+  return cfg
+
+
+# RL config.
+
+
+def cartpole_ppo_runner_cfg() -> RslRlOnPolicyRunnerCfg:
+  return RslRlOnPolicyRunnerCfg(
+    actor=RslRlModelCfg(
+      hidden_dims=(64, 64),
+      activation="elu",
+      obs_normalization=False,
+      distribution_cfg={
+        "class_name": "GaussianDistribution",
+        "init_std": 1.0,
+        "std_type": "scalar",
+      },
+    ),
+    critic=RslRlModelCfg(
+      hidden_dims=(64, 64),
+      activation="elu",
+      obs_normalization=False,
+    ),
+    algorithm=RslRlPpoAlgorithmCfg(
+      value_loss_coef=1.0,
+      use_clipped_value_loss=True,
+      clip_param=0.2,
+      entropy_coef=0.01,
+      num_learning_epochs=5,
+      num_mini_batches=4,
+      learning_rate=1.0e-3,
+      schedule="adaptive",
+      gamma=0.99,
+      lam=0.95,
+      desired_kl=0.01,
+      max_grad_norm=1.0,
+    ),
+    experiment_name="cartpole",
+    save_interval=50,
+    num_steps_per_env=32,
+    max_iterations=500,
+  )
diff --git a/src/mjlab/tasks/manipulation/__init__.py b/src/mjlab/tasks/manipulation/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/mjlab/tasks/manipulation/config/__init__.py b/src/mjlab/tasks/manipulation/config/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/mjlab/tasks/manipulation/config/yam/__init__.py b/src/mjlab/tasks/manipulation/config/yam/__init__.py
new file mode 100644
index 0000000..33a7dc4
--- /dev/null
+++ b/src/mjlab/tasks/manipulation/config/yam/__init__.py
@@ -0,0 +1,45 @@
+from mjlab.tasks.manipulation.rl import ManipulationOnPolicyRunner
+from mjlab.tasks.registry import register_mjlab_task
+
+from .env_cfgs import (
+  yam_lift_cube_env_cfg,
+  yam_lift_cube_vision_env_cfg,
+  yam_multi_cube_seg_env_cfg,
+)
+from .rl_cfg import (
+  yam_lift_cube_ppo_runner_cfg,
+  yam_lift_cube_vision_ppo_runner_cfg,
+  yam_multi_cube_seg_ppo_runner_cfg,
+)
+
+register_mjlab_task(
+  task_id="Mjlab-Lift-Cube-Yam",
+  env_cfg=yam_lift_cube_env_cfg(),
+  play_env_cfg=yam_lift_cube_env_cfg(play=True),
+  rl_cfg=yam_lift_cube_ppo_runner_cfg(),
+  runner_cls=ManipulationOnPolicyRunner,
+)
+
+register_mjlab_task(
+  task_id="Mjlab-Lift-Cube-Yam-Rgb",
+  env_cfg=yam_lift_cube_vision_env_cfg(cam_type="rgb"),
+  play_env_cfg=yam_lift_cube_vision_env_cfg(cam_type="rgb", play=True),
+  rl_cfg=yam_lift_cube_vision_ppo_runner_cfg(),
+  runner_cls=ManipulationOnPolicyRunner,
+)
+
+register_mjlab_task(
+  task_id="Mjlab-Lift-Cube-Yam-Depth",
+  env_cfg=yam_lift_cube_vision_env_cfg(cam_type="depth"),
+  play_env_cfg=yam_lift_cube_vision_env_cfg(cam_type="depth", play=True),
+  rl_cfg=yam_lift_cube_vision_ppo_runner_cfg(),
+  runner_cls=ManipulationOnPolicyRunner,
+)
+
+register_mjlab_task(
+  task_id="Mjlab-Multi-Cube-Seg-Yam",
+  env_cfg=yam_multi_cube_seg_env_cfg(num_cubes=3),
+  play_env_cfg=yam_multi_cube_seg_env_cfg(num_cubes=3, play=True),
+  rl_cfg=yam_multi_cube_seg_ppo_runner_cfg(),
+  runner_cls=ManipulationOnPolicyRunner,
+)
diff --git a/src/mjlab/tasks/manipulation/config/yam/env_cfgs.py b/src/mjlab/tasks/manipulation/config/yam/env_cfgs.py
new file mode 100644
index 0000000..9d70ace
--- /dev/null
+++ b/src/mjlab/tasks/manipulation/config/yam/env_cfgs.py
@@ -0,0 +1,296 @@
+import colorsys
+from typing import Any, Literal
+
+import mujoco
+
+from mjlab.asset_zoo.robots import (
+  YAM_ACTION_SCALE,
+  get_yam_robot_cfg,
+)
+from mjlab.entity import EntityCfg
+from mjlab.envs import ManagerBasedRlEnvCfg
+from mjlab.envs.mdp import dr
+from mjlab.envs.mdp.actions import JointPositionActionCfg
+from mjlab.managers import (
+  ObservationGroupCfg,
+  ObservationTermCfg,
+)
+from mjlab.managers.event_manager import EventTermCfg
+from mjlab.managers.reward_manager import RewardTermCfg
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.sensor import CameraSensorCfg, ContactSensorCfg
+from mjlab.tasks.manipulation import mdp as manipulation_mdp
+from mjlab.tasks.manipulation.lift_cube_env_cfg import make_lift_cube_env_cfg
+from mjlab.tasks.manipulation.mdp import MultiCubeLiftingCommandCfg
+
+
+def get_cube_spec(
+  cube_size: float = 0.02,
+  mass: float = 0.05,
+  rgba: tuple[float, float, float, float] = (0.8, 0.2, 0.2, 1.0),
+) -> mujoco.MjSpec:
+  spec = mujoco.MjSpec()
+  body = spec.worldbody.add_body(name="cube")
+  body.add_freejoint(name="cube_joint")
+  body.add_geom(
+    name="cube_geom",
+    type=mujoco.mjtGeom.mjGEOM_BOX,
+    size=(cube_size,) * 3,
+    mass=mass,
+    rgba=rgba,
+  )
+  return spec
+
+
+def yam_lift_cube_env_cfg(
+  play: bool = False,
+) -> ManagerBasedRlEnvCfg:
+  cfg = make_lift_cube_env_cfg()
+
+  cfg.scene.entities = {
+    "robot": get_yam_robot_cfg(),
+    "cube": EntityCfg(spec_fn=get_cube_spec),
+  }
+
+  joint_pos_action = cfg.actions["joint_pos"]
+  assert isinstance(joint_pos_action, JointPositionActionCfg)
+  joint_pos_action.scale = YAM_ACTION_SCALE
+
+  cfg.observations["actor"].terms["ee_to_cube"].params["asset_cfg"].site_names = (
+    "grasp_site",
+  )
+  cfg.rewards["lift"].params["asset_cfg"].site_names = ("grasp_site",)
+
+  fingertip_geoms = r"[lr]f_down(6|7|8|9|10|11)_collision"
+  cfg.events["fingertip_friction_slide"].params[
+    "asset_cfg"
+  ].geom_names = fingertip_geoms
+  cfg.events["fingertip_friction_spin"].params["asset_cfg"].geom_names = fingertip_geoms
+  cfg.events["fingertip_friction_roll"].params["asset_cfg"].geom_names = fingertip_geoms
+
+  # Configure collision sensor pattern.
+  assert cfg.scene.sensors is not None
+  for sensor in cfg.scene.sensors:
+    if sensor.name == "ee_ground_collision":
+      assert isinstance(sensor, ContactSensorCfg)
+      sensor.primary.pattern = "link_6"
+
+  cfg.viewer.body_name = "arm"
+
+  # Apply play mode overrides.
+  if play:
+    cfg.episode_length_s = int(1e9)
+    cfg.observations["actor"].enable_corruption = False
+    cfg.curriculum = {}
+
+    # Higher command resampling frequency for more dynamic play.
+    assert cfg.commands is not None
+    cfg.commands["lift_height"].resampling_time_range = (4.0, 4.0)
+
+  return cfg
+
+
+def yam_lift_cube_vision_env_cfg(
+  cam_type: Literal["rgb", "depth"],
+  play: bool = False,
+) -> ManagerBasedRlEnvCfg:
+  cfg = yam_lift_cube_env_cfg(play=play)
+
+  camera_names = ["robot/camera_d405"]
+  cam_kwargs = {
+    "robot/camera_d405": {
+      "height": 32,
+      "width": 32,
+    },
+  }
+  shared_cam_kwargs = dict(
+    data_types=(cam_type,),
+    enabled_geom_groups=(0, 3),
+    use_shadows=False,
+    use_textures=True,
+  )
+
+  cam_terms = {}
+  for cam_name in camera_names:
+    cam_cfg = CameraSensorCfg(
+      name=cam_name.split("/")[-1],
+      camera_name=cam_name,
+      **cam_kwargs[cam_name],  # type: ignore[invalid-argument-type]
+      **shared_cam_kwargs,
+    )
+    cfg.scene.sensors = (cfg.scene.sensors or ()) + (cam_cfg,)
+    param_kwargs: dict[str, Any] = {"sensor_name": cam_cfg.name}
+    if cam_type == "depth":
+      param_kwargs["cutoff_distance"] = 0.5
+      func = manipulation_mdp.camera_depth
+    else:
+      func = manipulation_mdp.camera_rgb
+    cam_terms[f"{cam_name.split('/')[-1]}_{cam_type}"] = ObservationTermCfg(
+      func=func, params=param_kwargs
+    )
+
+  camera_obs = ObservationGroupCfg(
+    terms=cam_terms, enable_corruption=False, concatenate_terms=True
+  )
+  cfg.observations["camera"] = camera_obs
+
+  if cam_type == "rgb":
+    cfg.events["cube_color"] = EventTermCfg(
+      func=dr.geom_rgba,
+      mode="reset",
+      params={
+        "asset_cfg": SceneEntityCfg("cube", geom_names=(".*",)),
+        "operation": "abs",
+        "distribution": "uniform",
+        "axes": [0, 1, 2],
+        "ranges": (0.0, 1.0),
+      },
+    )
+
+  # Pop privileged info from actor observations.
+  actor_obs = cfg.observations["actor"]
+  actor_obs.terms.pop("ee_to_cube")
+  actor_obs.terms.pop("cube_to_goal")
+
+  # Add goal_position to actor observations.
+  actor_obs.terms["goal_position"] = ObservationTermCfg(
+    func=manipulation_mdp.target_position,
+    params={
+      "command_name": "lift_height",
+      "asset_cfg": SceneEntityCfg("robot", site_names=("grasp_site",)),
+    },
+    # NOTE: No noise for goal position.
+  )
+
+  return cfg
+
+
+def _cube_color(i: int, n: int) -> tuple[float, float, float, float]:
+  """Generate a distinct color for cube i of n using HSV hue rotation."""
+  h = i / max(n, 1)
+  r, g, b = colorsys.hsv_to_rgb(h, 0.8, 0.9)
+  return (r, g, b, 1.0)
+
+
+def yam_multi_cube_seg_env_cfg(
+  num_cubes: int = 3,
+  play: bool = False,
+) -> ManagerBasedRlEnvCfg:
+  """Multi-cube task: depth + segmentation mask for goal conditioning."""
+  cfg = make_lift_cube_env_cfg()
+
+  cube_names = [f"cube_{i}" for i in range(num_cubes)]
+  entities: dict[str, EntityCfg] = {"robot": get_yam_robot_cfg()}
+  for i, name in enumerate(cube_names):
+    color = _cube_color(i, num_cubes)
+    entities[name] = EntityCfg(
+      spec_fn=lambda c=color: get_cube_spec(rgba=c),
+    )
+  cfg.scene.entities = entities
+
+  joint_pos_action = cfg.actions["joint_pos"]
+  assert isinstance(joint_pos_action, JointPositionActionCfg)
+  joint_pos_action.scale = YAM_ACTION_SCALE
+
+  cfg.commands = {
+    "lift_height": MultiCubeLiftingCommandCfg(
+      entity_names=tuple(cube_names),
+      resampling_time_range=(8.0, 12.0),
+      debug_vis=True,
+      difficulty="dynamic",
+    ),
+  }
+
+  cfg.rewards["lift"] = RewardTermCfg(
+    func=manipulation_mdp.multi_cube_staged_position_reward,
+    weight=1.0,
+    params={
+      "command_name": "lift_height",
+      "reaching_std": 0.2,
+      "bringing_std": 0.3,
+      "asset_cfg": SceneEntityCfg("robot", site_names=("grasp_site",)),
+    },
+  )
+  cfg.rewards["lift_precise"] = RewardTermCfg(
+    func=manipulation_mdp.multi_cube_bring_object_reward,
+    weight=1.0,
+    params={
+      "command_name": "lift_height",
+      "std": 0.05,
+    },
+  )
+
+  fingertip_geoms = r"[lr]f_down(6|7|8|9|10|11)_collision"
+  cfg.events["fingertip_friction_slide"].params[
+    "asset_cfg"
+  ].geom_names = fingertip_geoms
+  cfg.events["fingertip_friction_spin"].params["asset_cfg"].geom_names = fingertip_geoms
+  cfg.events["fingertip_friction_roll"].params["asset_cfg"].geom_names = fingertip_geoms
+
+  assert cfg.scene.sensors is not None
+  for sensor in cfg.scene.sensors:
+    if sensor.name == "ee_ground_collision":
+      assert isinstance(sensor, ContactSensorCfg)
+      sensor.primary.pattern = "link_6"
+
+  cfg.viewer.body_name = "arm"
+  cfg.sim.nconmax = max(cfg.sim.nconmax or 55, 55 + num_cubes * 120)
+
+  cam_cfg = CameraSensorCfg(
+    name="camera_d405",
+    camera_name="robot/camera_d405",
+    height=32,
+    width=32,
+    data_types=("depth", "segmentation"),
+    enabled_geom_groups=(0, 3),
+    use_shadows=False,
+    use_textures=True,
+  )
+  cfg.scene.sensors = (cfg.scene.sensors or ()) + (cam_cfg,)
+
+  cam_terms = {
+    "depth": ObservationTermCfg(
+      func=manipulation_mdp.camera_depth,
+      params={
+        "sensor_name": "camera_d405",
+        "cutoff_distance": 0.5,
+      },
+    ),
+    "target_mask": ObservationTermCfg(
+      func=manipulation_mdp.camera_target_cube_mask,
+      params={
+        "sensor_name": "camera_d405",
+        "command_name": "lift_height",
+      },
+    ),
+  }
+  cfg.observations["camera"] = ObservationGroupCfg(
+    terms=cam_terms,
+    enable_corruption=False,
+    concatenate_terms=True,
+    concatenate_dim=0,
+  )
+
+  for group_name in ("actor", "critic"):
+    obs = cfg.observations[group_name]
+    obs.terms.pop("ee_to_cube", None)
+    obs.terms.pop("cube_to_goal", None)
+    obs.terms["goal_position"] = ObservationTermCfg(
+      func=manipulation_mdp.target_position,
+      params={
+        "command_name": "lift_height",
+        "asset_cfg": SceneEntityCfg("robot", site_names=("grasp_site",)),
+      },
+    )
+
+  if play:
+    cfg.episode_length_s = int(1e9)
+    cfg.observations["actor"].enable_corruption = False
+    cfg.curriculum = {}
+    assert cfg.commands is not None
+    cfg.commands["lift_height"].resampling_time_range = (
+      4.0,
+      4.0,
+    )
+
+  return cfg
diff --git a/src/mjlab/tasks/manipulation/config/yam/rl_cfg.py b/src/mjlab/tasks/manipulation/config/yam/rl_cfg.py
new file mode 100644
index 0000000..c11ed96
--- /dev/null
+++ b/src/mjlab/tasks/manipulation/config/yam/rl_cfg.py
@@ -0,0 +1,150 @@
+from mjlab.rl import (
+  RslRlModelCfg,
+  RslRlOnPolicyRunnerCfg,
+  RslRlPpoAlgorithmCfg,
+)
+
+_VISION_CNN_CFG = {
+  "output_channels": [16, 32],
+  "kernel_size": [5, 3],
+  "stride": [2, 2],
+  "padding": "zeros",
+  "activation": "elu",
+  "max_pool": False,
+  "global_pool": "none",
+  "spatial_softmax": True,
+  "spatial_softmax_temperature": 1.0,
+}
+_VISION_MODEL_CLS = "mjlab.rl.spatial_softmax:SpatialSoftmaxCNNModel"
+
+
+def yam_lift_cube_ppo_runner_cfg() -> RslRlOnPolicyRunnerCfg:
+  return RslRlOnPolicyRunnerCfg(
+    actor=RslRlModelCfg(
+      hidden_dims=(512, 256, 128),
+      activation="elu",
+      obs_normalization=True,
+      distribution_cfg={
+        "class_name": "GaussianDistribution",
+        "init_std": 1.0,
+        "std_type": "scalar",
+      },
+    ),
+    critic=RslRlModelCfg(
+      hidden_dims=(512, 256, 128),
+      activation="elu",
+      obs_normalization=True,
+    ),
+    algorithm=RslRlPpoAlgorithmCfg(
+      value_loss_coef=1.0,
+      use_clipped_value_loss=True,
+      clip_param=0.2,
+      entropy_coef=0.005,
+      num_learning_epochs=5,
+      num_mini_batches=4,
+      learning_rate=1.0e-3,
+      schedule="adaptive",
+      gamma=0.99,
+      lam=0.95,
+      desired_kl=0.01,
+      max_grad_norm=1.0,
+    ),
+    experiment_name="yam_lift_cube",
+    save_interval=100,
+    num_steps_per_env=24,
+    max_iterations=5_000,
+  )
+
+
+def yam_lift_cube_vision_ppo_runner_cfg() -> RslRlOnPolicyRunnerCfg:
+  cnn_cfg = _VISION_CNN_CFG
+  class_name = _VISION_MODEL_CLS
+  return RslRlOnPolicyRunnerCfg(
+    actor=RslRlModelCfg(
+      hidden_dims=(256, 256, 128),
+      activation="elu",
+      obs_normalization=True,
+      cnn_cfg=cnn_cfg,
+      class_name=class_name,
+      distribution_cfg={
+        "class_name": "GaussianDistribution",
+        "init_std": 1.0,
+        "std_type": "scalar",
+      },
+    ),
+    critic=RslRlModelCfg(
+      hidden_dims=(256, 256, 128),
+      activation="elu",
+      obs_normalization=True,
+      cnn_cfg=cnn_cfg,
+      class_name=class_name,
+    ),
+    algorithm=RslRlPpoAlgorithmCfg(
+      value_loss_coef=1.0,
+      use_clipped_value_loss=True,
+      clip_param=0.2,
+      entropy_coef=0.005,
+      num_learning_epochs=5,
+      num_mini_batches=4,
+      learning_rate=1.0e-3,
+      schedule="adaptive",
+      gamma=0.99,
+      lam=0.95,
+      desired_kl=0.01,
+      max_grad_norm=1.0,
+    ),
+    experiment_name="yam_lift_cube_vision",
+    save_interval=100,
+    num_steps_per_env=24,
+    max_iterations=3_000,
+    obs_groups={
+      "actor": ("actor", "camera"),
+      "critic": ("critic", "camera"),
+    },
+  )
+
+
+def yam_multi_cube_seg_ppo_runner_cfg() -> RslRlOnPolicyRunnerCfg:
+  return RslRlOnPolicyRunnerCfg(
+    actor=RslRlModelCfg(
+      hidden_dims=(256, 256, 128),
+      activation="elu",
+      obs_normalization=True,
+      cnn_cfg=_VISION_CNN_CFG,
+      class_name=_VISION_MODEL_CLS,
+      distribution_cfg={
+        "class_name": "GaussianDistribution",
+        "init_std": 1.0,
+        "std_type": "scalar",
+      },
+    ),
+    critic=RslRlModelCfg(
+      hidden_dims=(256, 256, 128),
+      activation="elu",
+      obs_normalization=True,
+      cnn_cfg=_VISION_CNN_CFG,
+      class_name=_VISION_MODEL_CLS,
+    ),
+    algorithm=RslRlPpoAlgorithmCfg(
+      value_loss_coef=1.0,
+      use_clipped_value_loss=True,
+      clip_param=0.2,
+      entropy_coef=0.005,
+      num_learning_epochs=5,
+      num_mini_batches=4,
+      learning_rate=1.0e-3,
+      schedule="adaptive",
+      gamma=0.99,
+      lam=0.95,
+      desired_kl=0.01,
+      max_grad_norm=1.0,
+    ),
+    experiment_name="yam_multi_cube_seg",
+    save_interval=100,
+    num_steps_per_env=24,
+    max_iterations=3_000,
+    obs_groups={
+      "actor": ("actor", "camera"),
+      "critic": ("critic", "camera"),
+    },
+  )
diff --git a/src/mjlab/tasks/manipulation/lift_cube_env_cfg.py b/src/mjlab/tasks/manipulation/lift_cube_env_cfg.py
new file mode 100644
index 0000000..da43d7f
--- /dev/null
+++ b/src/mjlab/tasks/manipulation/lift_cube_env_cfg.py
@@ -0,0 +1,248 @@
+from mjlab.envs import ManagerBasedRlEnvCfg
+from mjlab.envs.mdp import dr
+from mjlab.envs.mdp.actions import JointPositionActionCfg
+from mjlab.managers.action_manager import ActionTermCfg
+from mjlab.managers.command_manager import CommandTermCfg
+from mjlab.managers.curriculum_manager import CurriculumTermCfg
+from mjlab.managers.event_manager import EventTermCfg
+from mjlab.managers.observation_manager import ObservationGroupCfg, ObservationTermCfg
+from mjlab.managers.reward_manager import RewardTermCfg
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.managers.termination_manager import TerminationTermCfg
+from mjlab.scene import SceneCfg
+from mjlab.sensor import ContactMatch, ContactSensorCfg
+from mjlab.sim import MujocoCfg, SimulationCfg
+from mjlab.tasks.manipulation import mdp as manipulation_mdp
+from mjlab.tasks.manipulation.mdp import LiftingCommandCfg
+from mjlab.tasks.velocity import mdp
+from mjlab.terrains import TerrainEntityCfg
+from mjlab.utils.noise import UniformNoiseCfg as Unoise
+from mjlab.viewer import ViewerConfig
+
+
+def make_lift_cube_env_cfg() -> ManagerBasedRlEnvCfg:
+  """Create base cube lifting task configuration."""
+
+  actor_terms = {
+    "joint_pos": ObservationTermCfg(
+      func=mdp.joint_pos_rel,
+      noise=Unoise(n_min=-0.01, n_max=0.01),
+    ),
+    "joint_vel": ObservationTermCfg(
+      func=mdp.joint_vel_rel,
+      noise=Unoise(n_min=-1.5, n_max=1.5),
+    ),
+    "ee_to_cube": ObservationTermCfg(
+      func=manipulation_mdp.ee_to_object_distance,
+      params={
+        "object_name": "cube",
+        "asset_cfg": SceneEntityCfg("robot", site_names=()),  # Set per-robot.
+      },
+      noise=Unoise(n_min=-0.01, n_max=0.01),
+    ),
+    "cube_to_goal": ObservationTermCfg(
+      func=manipulation_mdp.object_to_goal_distance,
+      params={
+        "object_name": "cube",
+        "command_name": "lift_height",
+      },
+      noise=Unoise(n_min=-0.01, n_max=0.01),
+    ),
+    "actions": ObservationTermCfg(func=mdp.last_action),
+  }
+
+  critic_terms = {**actor_terms}
+
+  observations = {
+    "actor": ObservationGroupCfg(actor_terms, enable_corruption=True),
+    "critic": ObservationGroupCfg(critic_terms, enable_corruption=False),
+  }
+
+  actions: dict[str, ActionTermCfg] = {
+    "joint_pos": JointPositionActionCfg(
+      entity_name="robot",
+      actuator_names=(".*",),
+      scale=0.5,  # Override per-robot.
+      use_default_offset=True,
+    )
+  }
+
+  commands: dict[str, CommandTermCfg] = {
+    "lift_height": LiftingCommandCfg(
+      entity_name="cube",
+      resampling_time_range=(8.0, 12.0),
+      debug_vis=True,
+      difficulty="dynamic",
+      object_pose_range=LiftingCommandCfg.ObjectPoseRangeCfg(
+        x=(0.2, 0.4),
+        y=(-0.2, 0.2),
+        z=(0.02, 0.05),
+        yaw=(-3.14, 3.14),
+      ),
+    )
+  }
+
+  events = {
+    # For positioning the base of the robot at env_origins.
+    "reset_base": EventTermCfg(
+      func=mdp.reset_root_state_uniform,
+      mode="reset",
+      params={
+        "pose_range": {},
+        "velocity_range": {},
+      },
+    ),
+    "reset_robot_joints": EventTermCfg(
+      func=mdp.reset_joints_by_offset,
+      mode="reset",
+      params={
+        "position_range": (0.0, 0.0),
+        "velocity_range": (0.0, 0.0),
+        "asset_cfg": SceneEntityCfg("robot", joint_names=(".*",)),
+      },
+    ),
+    "fingertip_friction_slide": EventTermCfg(
+      mode="startup",
+      func=dr.geom_friction,
+      params={
+        "asset_cfg": SceneEntityCfg("robot", geom_names=()),  # Set per-robot.
+        "operation": "abs",
+        "distribution": "uniform",
+        "axes": [0],
+        "ranges": (0.3, 1.5),
+      },
+    ),
+    "fingertip_friction_spin": EventTermCfg(
+      mode="startup",
+      func=dr.geom_friction,
+      params={
+        "asset_cfg": SceneEntityCfg("robot", geom_names=()),  # Set per-robot.
+        "operation": "abs",
+        "distribution": "log_uniform",
+        "axes": [1],
+        "ranges": (1e-4, 2e-2),
+      },
+    ),
+    "fingertip_friction_roll": EventTermCfg(
+      mode="startup",
+      func=dr.geom_friction,
+      params={
+        "asset_cfg": SceneEntityCfg("robot", geom_names=()),  # Set per-robot.
+        "operation": "abs",
+        "distribution": "log_uniform",
+        "axes": [2],
+        "ranges": (1e-5, 5e-3),
+      },
+    ),
+  }
+
+  # Collision sensor for end-effector to ground contact.
+  ee_ground_collision_cfg = ContactSensorCfg(
+    name="ee_ground_collision",
+    primary=ContactMatch(
+      mode="subtree",
+      pattern="",  # Set per-robot (e.g., "link_6" for all geoms in end-effector).
+      entity="robot",
+    ),
+    secondary=ContactMatch(mode="body", pattern="terrain"),
+    fields=("found", "force"),
+    reduce="none",
+    num_slots=1,
+    history_length=4,
+  )
+
+  rewards = {
+    "lift": RewardTermCfg(
+      func=manipulation_mdp.staged_position_reward,
+      weight=1.0,
+      params={
+        "command_name": "lift_height",
+        "object_name": "cube",
+        "reaching_std": 0.2,
+        "bringing_std": 0.3,
+        "asset_cfg": SceneEntityCfg("robot", site_names=()),  # Set per-robot.
+      },
+    ),
+    "lift_precise": RewardTermCfg(
+      func=manipulation_mdp.bring_object_reward,
+      weight=1.0,
+      params={
+        "command_name": "lift_height",
+        "object_name": "cube",
+        "std": 0.05,
+      },
+    ),
+    "action_rate_l2": RewardTermCfg(func=mdp.action_rate_l2, weight=-0.01),
+    "joint_pos_limits": RewardTermCfg(
+      func=mdp.joint_pos_limits,
+      weight=-10.0,
+      params={"asset_cfg": SceneEntityCfg("robot", joint_names=(".*",))},
+    ),
+    "joint_vel_hinge": RewardTermCfg(
+      func=manipulation_mdp.joint_velocity_hinge_penalty,
+      weight=-0.01,
+      params={
+        "max_vel": 0.5,
+        "asset_cfg": SceneEntityCfg("robot", joint_names=(".*",)),
+      },
+    ),
+  }
+
+  terminations = {
+    "time_out": TerminationTermCfg(func=mdp.time_out, time_out=True),
+    "ee_ground_collision": TerminationTermCfg(
+      func=manipulation_mdp.illegal_contact,
+      params={"sensor_name": "ee_ground_collision", "force_threshold": 10.0},
+    ),
+  }
+
+  curriculum = {
+    "joint_vel_hinge_weight": CurriculumTermCfg(
+      func=manipulation_mdp.reward_curriculum,
+      params={
+        "reward_name": "joint_vel_hinge",
+        "stages": [
+          {"step": 0, "weight": -0.01},
+          {"step": 500 * 24, "weight": -0.1},
+          {"step": 1000 * 24, "weight": -1.0},
+        ],
+      },
+    ),
+  }
+
+  return ManagerBasedRlEnvCfg(
+    scene=SceneCfg(
+      terrain=TerrainEntityCfg(terrain_type="plane"),
+      num_envs=1,
+      env_spacing=1.0,
+      sensors=(ee_ground_collision_cfg,),
+    ),
+    observations=observations,
+    actions=actions,
+    commands=commands,
+    events=events,
+    rewards=rewards,
+    terminations=terminations,
+    curriculum=curriculum,
+    viewer=ViewerConfig(
+      origin_type=ViewerConfig.OriginType.ASSET_BODY,
+      entity_name="robot",
+      body_name="",  # Set per-robot.
+      distance=1.5,
+      elevation=-5.0,
+      azimuth=120.0,
+    ),
+    sim=SimulationCfg(
+      nconmax=55,
+      njmax=600,
+      mujoco=MujocoCfg(
+        timestep=0.005,
+        iterations=10,
+        ls_iterations=20,
+        impratio=10,
+        cone="elliptic",
+      ),
+    ),
+    decimation=4,
+    episode_length_s=20.0,
+  )
diff --git a/src/mjlab/tasks/manipulation/mdp/__init__.py b/src/mjlab/tasks/manipulation/mdp/__init__.py
new file mode 100644
index 0000000..04844b0
--- /dev/null
+++ b/src/mjlab/tasks/manipulation/mdp/__init__.py
@@ -0,0 +1,6 @@
+from mjlab.envs.mdp import *  # noqa: F401, F403
+
+from .commands import *  # noqa: F403
+from .observations import *  # noqa: F403
+from .rewards import *  # noqa: F403
+from .terminations import *  # noqa: F403
diff --git a/src/mjlab/tasks/manipulation/mdp/commands.py b/src/mjlab/tasks/manipulation/mdp/commands.py
new file mode 100644
index 0000000..c609a6f
--- /dev/null
+++ b/src/mjlab/tasks/manipulation/mdp/commands.py
@@ -0,0 +1,352 @@
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Literal
+
+import torch
+
+from mjlab.entity import Entity
+from mjlab.managers.command_manager import CommandTerm, CommandTermCfg
+from mjlab.utils.lab_api.math import (
+  quat_from_euler_xyz,
+  sample_uniform,
+)
+
+if TYPE_CHECKING:
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+  from mjlab.viewer.debug_visualizer import DebugVisualizer
+
+
+class LiftingCommand(CommandTerm):
+  cfg: LiftingCommandCfg
+
+  def __init__(self, cfg: LiftingCommandCfg, env: ManagerBasedRlEnv):
+    super().__init__(cfg, env)
+
+    self.object: Entity = env.scene[cfg.entity_name]
+    self.target_pos = torch.zeros(self.num_envs, 3, device=self.device)
+    self.episode_success = torch.zeros(self.num_envs, device=self.device)
+    self._pending_forward = False
+
+    self.metrics["object_height"] = torch.zeros(self.num_envs, device=self.device)
+    self.metrics["position_error"] = torch.zeros(self.num_envs, device=self.device)
+    self.metrics["at_goal"] = torch.zeros(self.num_envs, device=self.device)
+    self.metrics["episode_success"] = torch.zeros(self.num_envs, device=self.device)
+
+  @property
+  def command(self) -> torch.Tensor:
+    return self.target_pos
+
+  def _update_metrics(self) -> None:
+    object_pos_w = self.object.data.root_link_pos_w
+    object_height = object_pos_w[:, 2]
+    position_error = torch.norm(self.target_pos - object_pos_w, dim=-1)
+    at_goal = (position_error < self.cfg.success_threshold).float()
+
+    # Latch episode_success to 1 once goal is reached.
+    self.episode_success = torch.maximum(self.episode_success, at_goal)
+
+    self.metrics["object_height"] = object_height
+    self.metrics["position_error"] = position_error
+    self.metrics["at_goal"] = at_goal
+    self.metrics["episode_success"] = self.episode_success
+
+  def compute_success(self) -> torch.Tensor:
+    position_error = self.metrics["position_error"]
+    return position_error < self.cfg.success_threshold
+
+  def _resample_command(self, env_ids: torch.Tensor) -> None:
+    n = len(env_ids)
+
+    # Reset episode success for resampled envs.
+    self.episode_success[env_ids] = 0.0
+
+    # Set target position based on difficulty mode.
+    if self.cfg.difficulty == "fixed":
+      target_pos = torch.tensor(
+        [0.4, 0.0, 0.3], device=self.device, dtype=torch.float32
+      ).expand(n, 3)
+      self.target_pos[env_ids] = target_pos + self._env.scene.env_origins[env_ids]
+    else:
+      assert self.cfg.difficulty == "dynamic"
+      r = self.cfg.target_position_range
+      lower = torch.tensor([r.x[0], r.y[0], r.z[0]], device=self.device)
+      upper = torch.tensor([r.x[1], r.y[1], r.z[1]], device=self.device)
+      target_pos = sample_uniform(lower, upper, (n, 3), device=self.device)
+      self.target_pos[env_ids] = target_pos + self._env.scene.env_origins[env_ids]
+
+    # Reset object to new position.
+    if self.cfg.object_pose_range is not None:
+      r = self.cfg.object_pose_range
+      lower = torch.tensor([r.x[0], r.y[0], r.z[0]], device=self.device)
+      upper = torch.tensor([r.x[1], r.y[1], r.z[1]], device=self.device)
+      pos = sample_uniform(lower, upper, (n, 3), device=self.device)
+      pos = pos + self._env.scene.env_origins[env_ids]
+
+      # Sample orientation (yaw only, keep upright).
+      yaw = sample_uniform(r.yaw[0], r.yaw[1], (n,), device=self.device)
+      quat = quat_from_euler_xyz(
+        torch.zeros(n, device=self.device),  # roll
+        torch.zeros(n, device=self.device),  # pitch
+        yaw,
+      )
+      pose = torch.cat([pos, quat], dim=-1)
+
+      velocity = torch.zeros(n, 6, device=self.device)
+
+      self.object.write_root_link_pose_to_sim(pose, env_ids=env_ids)
+      self.object.write_root_link_velocity_to_sim(velocity, env_ids=env_ids)
+      self._pending_forward = True
+
+  def reset(self, env_ids: torch.Tensor | slice | None) -> dict[str, float]:
+    extras = super().reset(env_ids)
+    # Reset-path resamples are followed by the env's own forward(); only
+    # compute-path resamples (timer expiry) need our refresh.
+    self._pending_forward = False
+    return extras
+
+  def _update_command(self, env_ids: torch.Tensor | None = None) -> None:
+    # Reset-vs-step context is handled via _pending_forward, not env_ids.
+    del env_ids
+    # A timer-expiry resample teleports the object after the step's single
+    # forward(); refresh kinematics so observations and sensors see the new
+    # pose instead of the pre-teleport one.
+    if self._pending_forward:
+      self._pending_forward = False
+      self._env.sim.forward()
+
+  def _debug_vis_impl(self, visualizer: DebugVisualizer) -> None:
+    env_indices = visualizer.get_env_indices(self.num_envs)
+    if not env_indices:
+      return
+
+    for batch in env_indices:
+      target_pos = self.target_pos[batch].cpu().numpy()
+      visualizer.add_sphere(
+        center=target_pos,
+        radius=0.03,
+        color=self.cfg.viz.target_color,
+        label=f"target_position_{batch}",
+      )
+
+
+class MultiCubeLiftingCommand(CommandTerm):
+  """Selects one of N cubes as the target at each reset."""
+
+  cfg: MultiCubeLiftingCommandCfg
+
+  def __init__(
+    self,
+    cfg: MultiCubeLiftingCommandCfg,
+    env: ManagerBasedRlEnv,
+  ):
+    super().__init__(cfg, env)
+
+    self.cubes = [env.scene[name] for name in cfg.entity_names]
+    self._num_cubes = len(self.cubes)
+
+    geom_ids = [c.indexing.geom_ids for c in self.cubes]
+    max_geoms = max(g.shape[0] for g in geom_ids)
+    self._padded_geom_ids = torch.full(
+      (self._num_cubes, max_geoms),
+      -999,
+      device=self.device,
+      dtype=geom_ids[0].dtype,
+    )
+    for i, g in enumerate(geom_ids):
+      self._padded_geom_ids[i, : g.shape[0]] = g
+
+    self.target_pos = torch.zeros(self.num_envs, 3, device=self.device)
+    self.episode_success = torch.zeros(self.num_envs, device=self.device)
+    self.target_selection = torch.zeros(
+      self.num_envs, dtype=torch.long, device=self.device
+    )
+
+    self._env_arange = torch.arange(self.num_envs, device=self.device)
+    self._cached_target_obj_pos = torch.zeros(self.num_envs, 3, device=self.device)
+    self._pending_forward = False
+
+    self.metrics["position_error"] = torch.zeros(self.num_envs, device=self.device)
+    self.metrics["at_goal"] = torch.zeros(self.num_envs, device=self.device)
+    self.metrics["episode_success"] = torch.zeros(self.num_envs, device=self.device)
+
+  @property
+  def command(self) -> torch.Tensor:
+    return self.target_pos
+
+  @property
+  def target_geom_ids(self) -> torch.Tensor:
+    """Geom IDs of the target cube per env. Shape: (B, K)."""
+    return self._padded_geom_ids[self.target_selection]
+
+  def target_object_pos(self) -> torch.Tensor:
+    """Position of the target cube per env.
+
+    Cached per step — updated in _update_metrics which runs before rewards.
+    """
+    return self._cached_target_obj_pos
+
+  def _target_object_pos_from_sim(self) -> torch.Tensor:
+    all_pos = torch.stack([c.data.root_link_pos_w for c in self.cubes])
+    return all_pos[self.target_selection, self._env_arange]
+
+  def _update_metrics(self) -> None:
+    self._cached_target_obj_pos = self._target_object_pos_from_sim()
+    obj_pos = self._cached_target_obj_pos
+    error = torch.norm(self.target_pos - obj_pos, dim=-1)
+    at_goal = (error < self.cfg.success_threshold).float()
+    self.episode_success = torch.maximum(self.episode_success, at_goal)
+    self.metrics["position_error"] = error
+    self.metrics["at_goal"] = at_goal
+    self.metrics["episode_success"] = self.episode_success
+
+  def compute_success(self) -> torch.Tensor:
+    return self.metrics["position_error"] < self.cfg.success_threshold
+
+  def _resample_command(self, env_ids: torch.Tensor) -> None:
+    n = len(env_ids)
+    self.episode_success[env_ids] = 0.0
+
+    self.target_selection[env_ids] = torch.randint(
+      0, self._num_cubes, (n,), device=self.device
+    )
+
+    if self.cfg.difficulty == "fixed":
+      target = torch.tensor([0.4, 0.0, 0.3], device=self.device).expand(n, 3)
+      self.target_pos[env_ids] = target + self._env.scene.env_origins[env_ids]
+    else:
+      r = self.cfg.target_position_range
+      lo = torch.tensor([r.x[0], r.y[0], r.z[0]], device=self.device)
+      hi = torch.tensor([r.x[1], r.y[1], r.z[1]], device=self.device)
+      target = sample_uniform(lo, hi, (n, 3), device=self.device)
+      self.target_pos[env_ids] = target + self._env.scene.env_origins[env_ids]
+
+    r = self.cfg.object_pose_range
+    lo = torch.tensor([r.x[0], r.y[0], r.z[0]], device=self.device)
+    hi = torch.tensor([r.x[1], r.y[1], r.z[1]], device=self.device)
+    for cube in self.cubes:
+      pos = sample_uniform(lo, hi, (n, 3), device=self.device)
+      pos = pos + self._env.scene.env_origins[env_ids]
+      yaw = sample_uniform(r.yaw[0], r.yaw[1], (n,), device=self.device)
+      quat = quat_from_euler_xyz(
+        torch.zeros(n, device=self.device),
+        torch.zeros(n, device=self.device),
+        yaw,
+      )
+      pose = torch.cat([pos, quat], dim=-1)
+      velocity = torch.zeros(n, 6, device=self.device)
+      cube.write_root_link_pose_to_sim(pose, env_ids=env_ids)
+      cube.write_root_link_velocity_to_sim(velocity, env_ids=env_ids)
+    self._pending_forward = True
+
+  def reset(self, env_ids: torch.Tensor | slice | None) -> dict[str, float]:
+    extras = super().reset(env_ids)
+    # Reset-path resamples are followed by the env's own forward(); only
+    # compute-path resamples (timer expiry) need our refresh.
+    self._pending_forward = False
+    return extras
+
+  def _update_command(self, env_ids: torch.Tensor | None = None) -> None:
+    # Reset-vs-step context is handled via _pending_forward, not env_ids.
+    del env_ids
+    # A timer-expiry resample teleports the cubes after the step's single
+    # forward(); refresh kinematics and the reward-path cache (updated in
+    # _update_metrics before the resample) so both see post-teleport state.
+    if self._pending_forward:
+      self._pending_forward = False
+      self._env.sim.forward()
+      self._cached_target_obj_pos = self._target_object_pos_from_sim()
+
+  def _debug_vis_impl(self, visualizer: DebugVisualizer) -> None:
+    env_indices = visualizer.get_env_indices(self.num_envs)
+    if not env_indices:
+      return
+    for batch in env_indices:
+      target_pos = self.target_pos[batch].cpu().numpy()
+      visualizer.add_sphere(
+        center=target_pos,
+        radius=0.03,
+        color=(1.0, 0.5, 0.0, 0.3),
+        label=f"target_position_{batch}",
+      )
+      cube_pos = self.target_object_pos()[batch].cpu().numpy()
+      marker = cube_pos.copy()
+      marker[2] += 0.04
+      visualizer.add_sphere(
+        center=marker,
+        radius=0.01,
+        color=(1.0, 0.0, 0.0, 1.0),
+        label=f"target_cube_marker_{batch}",
+      )
+
+
+@dataclass(kw_only=True)
+class MultiCubeLiftingCommandCfg(CommandTermCfg):
+  entity_names: tuple[str, ...] = ()
+  success_threshold: float = 0.05
+  difficulty: Literal["fixed", "dynamic"] = "fixed"
+
+  @dataclass
+  class TargetPositionRangeCfg:
+    x: tuple[float, float] = (0.3, 0.5)
+    y: tuple[float, float] = (-0.2, 0.2)
+    z: tuple[float, float] = (0.2, 0.4)
+
+  target_position_range: TargetPositionRangeCfg = field(
+    default_factory=TargetPositionRangeCfg
+  )
+
+  @dataclass
+  class ObjectPoseRangeCfg:
+    x: tuple[float, float] = (0.25, 0.40)
+    y: tuple[float, float] = (-0.15, 0.15)
+    z: tuple[float, float] = (0.02, 0.05)
+    yaw: tuple[float, float] = (-math.pi, math.pi)
+
+  object_pose_range: ObjectPoseRangeCfg = field(default_factory=ObjectPoseRangeCfg)
+
+  def build(self, env: ManagerBasedRlEnv) -> MultiCubeLiftingCommand:
+    return MultiCubeLiftingCommand(self, env)
+
+
+@dataclass(kw_only=True)
+class LiftingCommandCfg(CommandTermCfg):
+  entity_name: str
+  success_threshold: float = 0.05
+  difficulty: Literal["fixed", "dynamic"] = "fixed"
+
+  @dataclass
+  class TargetPositionRangeCfg:
+    """Configuration for target position sampling in dynamic mode."""
+
+    x: tuple[float, float] = (0.3, 0.5)
+    y: tuple[float, float] = (-0.2, 0.2)
+    z: tuple[float, float] = (0.2, 0.4)
+
+  # Only used in dynamic mode.
+  target_position_range: TargetPositionRangeCfg = field(
+    default_factory=TargetPositionRangeCfg
+  )
+
+  @dataclass
+  class ObjectPoseRangeCfg:
+    """Configuration for object pose sampling when resampling commands."""
+
+    x: tuple[float, float] = (0.3, 0.35)
+    y: tuple[float, float] = (-0.1, 0.1)
+    z: tuple[float, float] = (0.02, 0.05)
+    yaw: tuple[float, float] = (-math.pi, math.pi)
+
+  object_pose_range: ObjectPoseRangeCfg | None = field(
+    default_factory=ObjectPoseRangeCfg
+  )
+
+  @dataclass
+  class VizCfg:
+    target_color: tuple[float, float, float, float] = (1.0, 0.5, 0.0, 0.3)
+
+  viz: VizCfg = field(default_factory=VizCfg)
+
+  def build(self, env: ManagerBasedRlEnv) -> LiftingCommand:
+    return LiftingCommand(self, env)
diff --git a/src/mjlab/tasks/manipulation/mdp/observations.py b/src/mjlab/tasks/manipulation/mdp/observations.py
new file mode 100644
index 0000000..2ce431c
--- /dev/null
+++ b/src/mjlab/tasks/manipulation/mdp/observations.py
@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import mujoco
+import torch
+
+from mjlab.entity import Entity
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.sensor import CameraSensor
+from mjlab.tasks.manipulation.mdp.commands import (
+  LiftingCommand,
+  MultiCubeLiftingCommand,
+)
+from mjlab.utils.lab_api.math import quat_apply, quat_inv
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+_DEFAULT_ASSET_CFG = SceneEntityCfg("robot")
+
+
+def ee_to_object_distance(
+  env: ManagerBasedRlEnv,
+  object_name: str,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  """Distance vector from end effector to object in base frame."""
+  robot: Entity = env.scene[asset_cfg.name]
+  obj: Entity = env.scene[object_name]
+  ee_pos_w = robot.data.site_pos_w[:, asset_cfg.site_ids].squeeze(1)
+  obj_pos_w = obj.data.root_link_pos_w
+  distance_vec_w = obj_pos_w - ee_pos_w
+  base_quat_w = robot.data.root_link_quat_w
+  distance_vec_b = quat_apply(quat_inv(base_quat_w), distance_vec_w)
+  return distance_vec_b
+
+
+def object_to_goal_distance(
+  env: ManagerBasedRlEnv,
+  object_name: str,
+  command_name: str,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  """Distance vector from object to goal in base frame."""
+  command = env.command_manager.get_term(command_name)
+  if not isinstance(command, LiftingCommand):
+    raise TypeError(
+      f"Command '{command_name}' must be a LiftingCommand, got {type(command)}"
+    )
+  robot: Entity = env.scene[asset_cfg.name]
+  obj: Entity = env.scene[object_name]
+  obj_pos_w = obj.data.root_link_pos_w
+  goal_pos_w = command.target_pos
+  distance_vec_w = goal_pos_w - obj_pos_w
+  base_quat_w = robot.data.root_link_quat_w
+  distance_vec_b = quat_apply(quat_inv(base_quat_w), distance_vec_w)
+  return distance_vec_b
+
+
+def ee_velocity(
+  env: ManagerBasedRlEnv,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  """EE linear velocity in EE frame."""
+  robot: Entity = env.scene[asset_cfg.name]
+  ee_vel_w = robot.data.site_vel_w[:, asset_cfg.site_ids].squeeze(1)  # (B, 6)
+  ee_vel_linear_w = ee_vel_w[:, :3]
+  ee_quat_w = robot.data.site_quat_w[:, asset_cfg.site_ids].squeeze(1)
+  ee_vel_linear_ee = quat_apply(quat_inv(ee_quat_w), ee_vel_linear_w)
+  return ee_vel_linear_ee
+
+
+def target_position(
+  env: ManagerBasedRlEnv,
+  command_name: str,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  """Target position in EE frame."""
+  command = env.command_manager.get_term(command_name)
+  if not isinstance(command, (LiftingCommand, MultiCubeLiftingCommand)):
+    raise TypeError(
+      f"Command '{command_name}' must be a LiftingCommand or "
+      f"MultiCubeLiftingCommand, got {type(command)}"
+    )
+  robot: Entity = env.scene[asset_cfg.name]
+  ee_pos_w = robot.data.site_pos_w[:, asset_cfg.site_ids].squeeze(1)
+  ee_quat_w = robot.data.site_quat_w[:, asset_cfg.site_ids].squeeze(1)
+  target_pos_w = command.target_pos
+  target_pos_rel_w = target_pos_w - ee_pos_w
+  target_pos_ee = quat_apply(quat_inv(ee_quat_w), target_pos_rel_w)
+  return target_pos_ee
+
+
+def camera_rgb(env: ManagerBasedRlEnv, sensor_name: str) -> torch.Tensor:
+  """RGB observation in CNN-compatible format (B, C, H, W)."""
+  sensor: CameraSensor = env.scene[sensor_name]
+  rgb_data = sensor.data.rgb  # (B, H, W, 3)
+  assert rgb_data is not None, f"Camera '{sensor_name}' has no RGB data"
+  rgb_data = rgb_data.permute(0, 3, 1, 2)  # (B, 3, H, W)
+  return rgb_data.float() / 255.0
+
+
+def camera_depth(
+  env: ManagerBasedRlEnv,
+  sensor_name: str,
+  cutoff_distance: float,
+  min_depth: float = 0.01,
+) -> torch.Tensor:
+  """Depth observation in CNN-compatible format (B, 1, H, W)."""
+  sensor: CameraSensor = env.scene[sensor_name]
+  depth_data = sensor.data.depth  # (B, H, W, 1)
+  assert depth_data is not None, f"Camera '{sensor_name}' has no depth data"
+  depth_data = depth_data.permute(0, 3, 1, 2)  # (B, 1, H, W)
+  depth_data_clipped = torch.clamp(depth_data, min=min_depth, max=cutoff_distance)
+  return torch.clamp(depth_data_clipped / cutoff_distance, 0.0, 1.0)
+
+
+def camera_segmentation(
+  env: ManagerBasedRlEnv,
+  sensor_name: str,
+) -> torch.Tensor:
+  """Per-pixel typed segmentation in (B, 2, H, W) format."""
+  sensor: CameraSensor = env.scene[sensor_name]
+  seg_data = sensor.data.segmentation  # (B, H, W, 2)
+  assert seg_data is not None, f"Camera '{sensor_name}' has no segmentation data"
+  return seg_data.permute(0, 3, 1, 2)  # (B, 2, H, W)
+
+
+def camera_target_cube_mask(
+  env: ManagerBasedRlEnv,
+  sensor_name: str,
+  command_name: str,
+) -> torch.Tensor:
+  """Binary mask of the target cube selected by a MultiCubeLiftingCommand.
+
+  Output shape: (B, 1, H, W) float32.
+  """
+  sensor: CameraSensor = env.scene[sensor_name]
+  seg_data = sensor.data.segmentation  # (B, H, W, 2)
+  assert seg_data is not None, f"Camera '{sensor_name}' has no segmentation data"
+  obj_ids = seg_data[..., 0]  # (B, H, W)
+  obj_types = seg_data[..., 1]  # (B, H, W)
+
+  command = env.command_manager.get_term(command_name)
+  assert isinstance(command, MultiCubeLiftingCommand)
+  target_ids = command.target_geom_ids  # (B, K)
+
+  # Only geom hits should participate in the target mask.
+  is_geom = obj_types == int(mujoco.mjtObj.mjOBJ_GEOM)
+  mask = (obj_ids.unsqueeze(-1) == target_ids.unsqueeze(1).unsqueeze(1)).any(-1)
+  mask = mask & is_geom
+  return mask.float().unsqueeze(1)  # (B, 1, H, W)
diff --git a/src/mjlab/tasks/manipulation/mdp/rewards.py b/src/mjlab/tasks/manipulation/mdp/rewards.py
new file mode 100644
index 0000000..47870e3
--- /dev/null
+++ b/src/mjlab/tasks/manipulation/mdp/rewards.py
@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+import torch
+
+from mjlab.entity import Entity
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.tasks.manipulation.mdp.commands import (
+  LiftingCommand,
+  MultiCubeLiftingCommand,
+)
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+_DEFAULT_ASSET_CFG = SceneEntityCfg("robot")
+
+
+def staged_position_reward(
+  env: ManagerBasedRlEnv,
+  command_name: str,
+  object_name: str,
+  reaching_std: float,
+  bringing_std: float,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  """Curriculum reward that gates lifting bonus on reaching progress.
+
+  Returns reaching * (1 + bringing), where both terms are Gaussian kernels
+  over position error. Ensures learning signal for approach before lift.
+  """
+  robot: Entity = env.scene[asset_cfg.name]
+  obj: Entity = env.scene[object_name]
+  command = cast(LiftingCommand, env.command_manager.get_term(command_name))
+  ee_pos_w = robot.data.site_pos_w[:, asset_cfg.site_ids].squeeze(1)
+  obj_pos_w = obj.data.root_link_pos_w
+  reach_error = torch.sum(torch.square(ee_pos_w - obj_pos_w), dim=-1)
+  reaching = torch.exp(-reach_error / reaching_std**2)
+  position_error = torch.sum(torch.square(command.target_pos - obj_pos_w), dim=-1)
+  bringing = torch.exp(-position_error / bringing_std**2)
+  return reaching * (1.0 + bringing)
+
+
+def bring_object_reward(
+  env: ManagerBasedRlEnv,
+  command_name: str,
+  object_name: str,
+  std: float,
+) -> torch.Tensor:
+  obj: Entity = env.scene[object_name]
+  command = cast(LiftingCommand, env.command_manager.get_term(command_name))
+  position_error = torch.sum(
+    torch.square(command.target_pos - obj.data.root_link_pos_w), dim=-1
+  )
+  return torch.exp(-position_error / std**2)
+
+
+def multi_cube_staged_position_reward(
+  env: ManagerBasedRlEnv,
+  command_name: str,
+  reaching_std: float,
+  bringing_std: float,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  """Staged reward for the target cube selected by MultiCubeLiftingCommand."""
+  robot: Entity = env.scene[asset_cfg.name]
+  command = env.command_manager.get_term(command_name)
+  if not isinstance(command, MultiCubeLiftingCommand):
+    raise TypeError(
+      f"Command '{command_name}' must be a MultiCubeLiftingCommand, got {type(command)}"
+    )
+  ee_pos_w = robot.data.site_pos_w[:, asset_cfg.site_ids].squeeze(1)
+  obj_pos_w = command.target_object_pos()
+  reach_error = torch.sum(torch.square(ee_pos_w - obj_pos_w), dim=-1)
+  reaching = torch.exp(-reach_error / reaching_std**2)
+  position_error = torch.sum(torch.square(command.target_pos - obj_pos_w), dim=-1)
+  bringing = torch.exp(-position_error / bringing_std**2)
+  return reaching * (1.0 + bringing)
+
+
+def multi_cube_bring_object_reward(
+  env: ManagerBasedRlEnv,
+  command_name: str,
+  std: float,
+) -> torch.Tensor:
+  """Gaussian reward for bringing the selected target cube to goal."""
+  command = env.command_manager.get_term(command_name)
+  if not isinstance(command, MultiCubeLiftingCommand):
+    raise TypeError(
+      f"Command '{command_name}' must be a MultiCubeLiftingCommand, got {type(command)}"
+    )
+  obj_pos_w = command.target_object_pos()
+  position_error = torch.sum(torch.square(command.target_pos - obj_pos_w), dim=-1)
+  return torch.exp(-position_error / std**2)
+
+
+def joint_velocity_hinge_penalty(
+  env: ManagerBasedRlEnv,
+  max_vel: float,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  """Quadratic hinge penalty on joint velocities exceeding a symmetric limit.
+
+  Penalizes only the amount by which |v| exceeds max_vel. Returns a negative
+  penalty, shaped as the negative squared L2 norm of the excess velocities.
+  """
+  robot: Entity = env.scene[asset_cfg.name]
+  joint_vel = robot.data.joint_vel[:, asset_cfg.joint_ids]
+  excess = (joint_vel.abs() - max_vel).clamp_min(0.0)
+  return (excess**2).sum(dim=-1)
diff --git a/src/mjlab/tasks/manipulation/mdp/terminations.py b/src/mjlab/tasks/manipulation/mdp/terminations.py
new file mode 100644
index 0000000..6e98b9a
--- /dev/null
+++ b/src/mjlab/tasks/manipulation/mdp/terminations.py
@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.sensor import ContactSensor
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+def illegal_contact(
+  env: ManagerBasedRlEnv,
+  sensor_name: str,
+  force_threshold: float = 10.0,
+) -> torch.Tensor:
+  sensor: ContactSensor = env.scene[sensor_name]
+  data = sensor.data
+  if data.force_history is not None:
+    # force_history: [B, N, H, 3]
+    force_mag = torch.norm(data.force_history, dim=-1)  # [B, N, H]
+    return (force_mag > force_threshold).any(dim=-1).any(dim=-1)  # [B]
+  assert data.found is not None
+  return torch.any(data.found, dim=-1)
diff --git a/src/mjlab/tasks/manipulation/rl/__init__.py b/src/mjlab/tasks/manipulation/rl/__init__.py
new file mode 100644
index 0000000..46098ee
--- /dev/null
+++ b/src/mjlab/tasks/manipulation/rl/__init__.py
@@ -0,0 +1,3 @@
+from mjlab.tasks.manipulation.rl.runner import (
+  ManipulationOnPolicyRunner as ManipulationOnPolicyRunner,
+)
diff --git a/src/mjlab/tasks/manipulation/rl/runner.py b/src/mjlab/tasks/manipulation/rl/runner.py
new file mode 100644
index 0000000..5c7da2e
--- /dev/null
+++ b/src/mjlab/tasks/manipulation/rl/runner.py
@@ -0,0 +1,30 @@
+import wandb
+from rsl_rl.utils import WandbLogWriter
+
+from mjlab.rl import RslRlVecEnvWrapper
+from mjlab.rl.exporter_utils import (
+  attach_metadata_to_onnx,
+  get_base_metadata,
+)
+from mjlab.rl.runner import MjlabOnPolicyRunner
+
+
+class ManipulationOnPolicyRunner(MjlabOnPolicyRunner):
+  env: RslRlVecEnvWrapper
+
+  def save(self, path: str, infos=None):
+    super().save(path, infos)
+    policy_dir, filename, onnx_path = self._get_export_paths(path)
+    try:
+      self.export_policy_to_onnx(str(policy_dir), filename)
+      is_wandb = isinstance(self.logger.writer, WandbLogWriter)
+      run_name: str = wandb.run.name if is_wandb and wandb.run else "local"  # type: ignore[assignment]
+      metadata = get_base_metadata(self.env.unwrapped, run_name)
+      attach_metadata_to_onnx(str(onnx_path), metadata)
+      if is_wandb and self.cfg["upload_model"]:
+        wandb.save(
+          str(onnx_path),
+          base_path=str(policy_dir),
+        )
+    except Exception as e:
+      print(f"[WARN] ONNX export failed (training continues): {e}")
diff --git a/src/mjlab/tasks/registry.py b/src/mjlab/tasks/registry.py
new file mode 100644
index 0000000..4b28efb
--- /dev/null
+++ b/src/mjlab/tasks/registry.py
@@ -0,0 +1,71 @@
+"""Task registry system for managing environment registration and creation."""
+
+from copy import deepcopy
+from dataclasses import dataclass
+
+from mjlab.envs import ManagerBasedRlEnvCfg
+from mjlab.rl import RslRlBaseRunnerCfg
+
+
+@dataclass
+class _TaskCfg:
+  env_cfg: ManagerBasedRlEnvCfg
+  play_env_cfg: ManagerBasedRlEnvCfg
+  rl_cfg: RslRlBaseRunnerCfg
+  runner_cls: type | None
+
+
+# Private module-level registry: task_id -> task config.
+_REGISTRY: dict[str, _TaskCfg] = {}
+
+
+def register_mjlab_task(
+  task_id: str,
+  env_cfg: ManagerBasedRlEnvCfg,
+  play_env_cfg: ManagerBasedRlEnvCfg,
+  rl_cfg: RslRlBaseRunnerCfg,
+  runner_cls: type | None = None,
+) -> None:
+  """Register an environment task.
+
+  Args:
+    task_id: Unique task identifier (e.g., "Mjlab-Velocity-Rough-Unitree-Go1").
+    env_cfg: Environment configuration used for training.
+    play_env_cfg: Environment configuration in "play" mode.
+    rl_cfg: RL runner configuration.
+    runner_cls: Optional custom runner class. If None, uses OnPolicyRunner.
+  """
+  if task_id in _REGISTRY:
+    raise ValueError(f"Task '{task_id}' is already registered")
+  _REGISTRY[task_id] = _TaskCfg(env_cfg, play_env_cfg, rl_cfg, runner_cls)
+
+
+def list_tasks() -> list[str]:
+  """List all registered task IDs."""
+  return sorted(_REGISTRY.keys())
+
+
+def load_env_cfg(task_name: str, play: bool = False) -> ManagerBasedRlEnvCfg:
+  """Load environment configuration for a task.
+
+  Returns a deep copy to prevent mutation of the registered config.
+  """
+  return deepcopy(
+    _REGISTRY[task_name].env_cfg if not play else _REGISTRY[task_name].play_env_cfg
+  )
+
+
+def load_rl_cfg(task_name: str) -> RslRlBaseRunnerCfg:
+  """Load RL configuration for a task.
+
+  Returns a deep copy to prevent mutation of the registered config.
+  """
+  return deepcopy(_REGISTRY[task_name].rl_cfg)
+
+
+def load_runner_cls(task_name: str) -> type | None:
+  """Load the runner class for a task.
+
+  If None, the default OnPolicyRunner will be used.
+  """
+  return _REGISTRY[task_name].runner_cls
diff --git a/src/mjlab/tasks/tracking/__init__.py b/src/mjlab/tasks/tracking/__init__.py
new file mode 100644
index 0000000..5c2d757
--- /dev/null
+++ b/src/mjlab/tasks/tracking/__init__.py
@@ -0,0 +1 @@
+"""Motion imitation environments for legged robots."""
diff --git a/src/mjlab/tasks/tracking/config/__init__.py b/src/mjlab/tasks/tracking/config/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/mjlab/tasks/tracking/config/g1/__init__.py b/src/mjlab/tasks/tracking/config/g1/__init__.py
new file mode 100644
index 0000000..0bd75b4
--- /dev/null
+++ b/src/mjlab/tasks/tracking/config/g1/__init__.py
@@ -0,0 +1,21 @@
+from mjlab.tasks.registry import register_mjlab_task
+from mjlab.tasks.tracking.rl import MotionTrackingOnPolicyRunner
+
+from .env_cfgs import unitree_g1_flat_tracking_env_cfg
+from .rl_cfg import unitree_g1_tracking_ppo_runner_cfg
+
+register_mjlab_task(
+  task_id="Mjlab-Tracking-Flat-Unitree-G1",
+  env_cfg=unitree_g1_flat_tracking_env_cfg(),
+  play_env_cfg=unitree_g1_flat_tracking_env_cfg(play=True),
+  rl_cfg=unitree_g1_tracking_ppo_runner_cfg(),
+  runner_cls=MotionTrackingOnPolicyRunner,
+)
+
+register_mjlab_task(
+  task_id="Mjlab-Tracking-Flat-Unitree-G1-No-State-Estimation",
+  env_cfg=unitree_g1_flat_tracking_env_cfg(has_state_estimation=False),
+  play_env_cfg=unitree_g1_flat_tracking_env_cfg(has_state_estimation=False, play=True),
+  rl_cfg=unitree_g1_tracking_ppo_runner_cfg(),
+  runner_cls=MotionTrackingOnPolicyRunner,
+)
diff --git a/src/mjlab/tasks/tracking/config/g1/env_cfgs.py b/src/mjlab/tasks/tracking/config/g1/env_cfgs.py
new file mode 100644
index 0000000..e2e30a9
--- /dev/null
+++ b/src/mjlab/tasks/tracking/config/g1/env_cfgs.py
@@ -0,0 +1,100 @@
+"""Unitree G1 flat tracking environment configurations."""
+
+from mjlab.asset_zoo.robots import (
+  G1_ACTION_SCALE,
+  get_g1_robot_cfg,
+)
+from mjlab.envs import ManagerBasedRlEnvCfg
+from mjlab.envs.mdp.actions import JointPositionActionCfg
+from mjlab.managers.observation_manager import ObservationGroupCfg
+from mjlab.sensor import ContactMatch, ContactSensorCfg
+from mjlab.tasks.tracking.mdp import MotionCommandCfg
+from mjlab.tasks.tracking.tracking_env_cfg import make_tracking_env_cfg
+
+
+def unitree_g1_flat_tracking_env_cfg(
+  has_state_estimation: bool = True,
+  play: bool = False,
+) -> ManagerBasedRlEnvCfg:
+  """Create Unitree G1 flat terrain tracking configuration."""
+  cfg = make_tracking_env_cfg()
+
+  cfg.scene.entities = {"robot": get_g1_robot_cfg()}
+
+  self_collision_cfg = ContactSensorCfg(
+    name="self_collision",
+    primary=ContactMatch(mode="subtree", pattern="pelvis", entity="robot"),
+    secondary=ContactMatch(mode="subtree", pattern="pelvis", entity="robot"),
+    fields=("found", "force"),
+    reduce="none",
+    num_slots=1,
+    history_length=4,
+  )
+  cfg.scene.sensors = (self_collision_cfg,)
+
+  joint_pos_action = cfg.actions["joint_pos"]
+  assert isinstance(joint_pos_action, JointPositionActionCfg)
+  joint_pos_action.scale = G1_ACTION_SCALE
+
+  motion_cmd = cfg.commands["motion"]
+  assert isinstance(motion_cmd, MotionCommandCfg)
+  motion_cmd.anchor_body_name = "torso_link"
+  motion_cmd.body_names = (
+    "pelvis",
+    "left_hip_roll_link",
+    "left_knee_link",
+    "left_ankle_roll_link",
+    "right_hip_roll_link",
+    "right_knee_link",
+    "right_ankle_roll_link",
+    "torso_link",
+    "left_shoulder_roll_link",
+    "left_elbow_link",
+    "left_wrist_yaw_link",
+    "right_shoulder_roll_link",
+    "right_elbow_link",
+    "right_wrist_yaw_link",
+  )
+
+  cfg.events["foot_friction"].params[
+    "asset_cfg"
+  ].geom_names = r"^(left|right)_foot[1-7]_collision$"
+  cfg.events["base_com"].params["asset_cfg"].body_names = ("torso_link",)
+
+  cfg.terminations["ee_body_pos"].params["body_names"] = (
+    "left_ankle_roll_link",
+    "right_ankle_roll_link",
+    "left_wrist_yaw_link",
+    "right_wrist_yaw_link",
+  )
+
+  cfg.viewer.body_name = "torso_link"
+
+  # Modify observations if we don't have state estimation.
+  if not has_state_estimation:
+    new_actor_terms = {
+      k: v
+      for k, v in cfg.observations["actor"].terms.items()
+      if k not in ["motion_anchor_pos_b", "base_lin_vel"]
+    }
+    cfg.observations["actor"] = ObservationGroupCfg(
+      terms=new_actor_terms,
+      concatenate_terms=True,
+      enable_corruption=True,
+    )
+
+  # Apply play mode overrides.
+  if play:
+    # Effectively infinite episode length.
+    cfg.episode_length_s = int(1e9)
+
+    cfg.observations["actor"].enable_corruption = False
+    cfg.events.pop("push_robot", None)
+
+    # Disable RSI randomization.
+    motion_cmd.pose_range = {}
+    motion_cmd.velocity_range = {}
+
+    motion_cmd.sampling_mode = "start"
+
+  return cfg
diff --git a/src/mjlab/tasks/tracking/config/g1/rl_cfg.py b/src/mjlab/tasks/tracking/config/g1/rl_cfg.py
new file mode 100644
index 0000000..fd870f9
--- /dev/null
+++ b/src/mjlab/tasks/tracking/config/g1/rl_cfg.py
@@ -0,0 +1,46 @@
+"""RL configuration for Unitree G1 tracking task."""
+
+from mjlab.rl import (
+  RslRlModelCfg,
+  RslRlOnPolicyRunnerCfg,
+  RslRlPpoAlgorithmCfg,
+)
+
+
+def unitree_g1_tracking_ppo_runner_cfg() -> RslRlOnPolicyRunnerCfg:
+  """Create RL runner configuration for Unitree G1 tracking task."""
+  return RslRlOnPolicyRunnerCfg(
+    actor=RslRlModelCfg(
+      hidden_dims=(512, 256, 128),
+      activation="elu",
+      obs_normalization=True,
+      distribution_cfg={
+        "class_name": "GaussianDistribution",
+        "init_std": 1.0,
+        "std_type": "scalar",
+      },
+    ),
+    critic=RslRlModelCfg(
+      hidden_dims=(512, 256, 128),
+      activation="elu",
+      obs_normalization=True,
+    ),
+    algorithm=RslRlPpoAlgorithmCfg(
+      value_loss_coef=1.0,
+      use_clipped_value_loss=True,
+      clip_param=0.2,
+      entropy_coef=0.005,
+      num_learning_epochs=5,
+      num_mini_batches=4,
+      learning_rate=1.0e-3,
+      schedule="adaptive",
+      gamma=0.99,
+      lam=0.95,
+      desired_kl=0.01,
+      max_grad_norm=1.0,
+    ),
+    experiment_name="g1_tracking",
+    save_interval=500,
+    num_steps_per_env=24,
+    max_iterations=30_000,
+  )
diff --git a/src/mjlab/tasks/tracking/mdp/__init__.py b/src/mjlab/tasks/tracking/mdp/__init__.py
new file mode 100644
index 0000000..fd0a633
--- /dev/null
+++ b/src/mjlab/tasks/tracking/mdp/__init__.py
@@ -0,0 +1,7 @@
+from mjlab.envs.mdp import *  # noqa: F401, F403
+
+from .commands import *  # noqa: F403
+from .metrics import *  # noqa: F403
+from .observations import *  # noqa: F403
+from .rewards import *  # noqa: F403
+from .terminations import *  # noqa: F403
diff --git a/src/mjlab/tasks/tracking/mdp/commands.py b/src/mjlab/tasks/tracking/mdp/commands.py
new file mode 100644
index 0000000..9bc2369
--- /dev/null
+++ b/src/mjlab/tasks/tracking/mdp/commands.py
@@ -0,0 +1,630 @@
+from __future__ import annotations
+
+import copy
+import math
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Literal
+
+import numpy as np
+import torch
+
+from mjlab.managers import CommandTerm, CommandTermCfg
+from mjlab.utils.lab_api.math import (
+  matrix_from_quat,
+  quat_apply,
+  quat_error_magnitude,
+  quat_from_euler_xyz,
+  quat_inv,
+  quat_mul,
+  sample_uniform,
+  yaw_quat,
+)
+from mjlab.viewer.debug_visualizer import DebugVisualizer
+
+if TYPE_CHECKING:
+  from collections.abc import Callable
+  from typing import Any
+
+  import viser
+
+  from mjlab.entity import Entity
+  from mjlab.envs import ManagerBasedRlEnv
+
+_DESIRED_FRAME_COLORS = ((1.0, 0.5, 0.5), (0.5, 1.0, 0.5), (0.5, 0.5, 1.0))
+
+
+class MotionLoader:
+  def __init__(
+    self, motion_file: str, body_indexes: torch.Tensor, device: str = "cpu"
+  ) -> None:
+    data = np.load(motion_file)
+    self.joint_pos = torch.tensor(data["joint_pos"], dtype=torch.float32, device=device)
+    self.joint_vel = torch.tensor(data["joint_vel"], dtype=torch.float32, device=device)
+    self._body_pos_w = torch.tensor(
+      data["body_pos_w"], dtype=torch.float32, device=device
+    )
+    self._body_quat_w = torch.tensor(
+      data["body_quat_w"], dtype=torch.float32, device=device
+    )
+    self._body_lin_vel_w = torch.tensor(
+      data["body_lin_vel_w"], dtype=torch.float32, device=device
+    )
+    self._body_ang_vel_w = torch.tensor(
+      data["body_ang_vel_w"], dtype=torch.float32, device=device
+    )
+    self._body_indexes = body_indexes
+    self.body_pos_w = self._body_pos_w[:, self._body_indexes]
+    self.body_quat_w = self._body_quat_w[:, self._body_indexes]
+    self.body_lin_vel_w = self._body_lin_vel_w[:, self._body_indexes]
+    self.body_ang_vel_w = self._body_ang_vel_w[:, self._body_indexes]
+    self.time_step_total = self.joint_pos.shape[0]
+
+
+class MotionCommand(CommandTerm):
+  cfg: MotionCommandCfg
+  _env: ManagerBasedRlEnv
+
+  def __init__(self, cfg: MotionCommandCfg, env: ManagerBasedRlEnv):
+    super().__init__(cfg, env)
+
+    self.robot: Entity = env.scene[cfg.entity_name]
+    self.robot_anchor_body_index = self.robot.body_names.index(
+      self.cfg.anchor_body_name
+    )
+    self.motion_anchor_body_index = self.cfg.body_names.index(self.cfg.anchor_body_name)
+    self.body_indexes = torch.tensor(
+      self.robot.find_bodies(self.cfg.body_names, preserve_order=True)[0],
+      dtype=torch.long,
+      device=self.device,
+    )
+
+    self.motion = MotionLoader(
+      self.cfg.motion_file, self.body_indexes, device=self.device
+    )
+    self.time_steps = torch.zeros(self.num_envs, dtype=torch.long, device=self.device)
+    self.body_pos_relative_w = torch.zeros(
+      self.num_envs, len(cfg.body_names), 3, device=self.device
+    )
+    self.body_quat_relative_w = torch.zeros(
+      self.num_envs, len(cfg.body_names), 4, device=self.device
+    )
+    self.body_quat_relative_w[:, :, 0] = 1.0
+
+    self.bin_count = int(self.motion.time_step_total // (1 / env.step_dt)) + 1
+    self.bin_failed_count = torch.zeros(
+      self.bin_count, dtype=torch.float, device=self.device
+    )
+    self._current_bin_failed = torch.zeros(
+      self.bin_count, dtype=torch.float, device=self.device
+    )
+    self.kernel = torch.tensor(
+      [self.cfg.adaptive_lambda**i for i in range(self.cfg.adaptive_kernel_size)],
+      device=self.device,
+    )
+    self.kernel = self.kernel / self.kernel.sum()
+
+    self.metrics["error_anchor_pos"] = torch.zeros(self.num_envs, device=self.device)
+    self.metrics["error_anchor_rot"] = torch.zeros(self.num_envs, device=self.device)
+    self.metrics["error_anchor_lin_vel"] = torch.zeros(
+      self.num_envs, device=self.device
+    )
+    self.metrics["error_anchor_ang_vel"] = torch.zeros(
+      self.num_envs, device=self.device
+    )
+    self.metrics["error_body_pos"] = torch.zeros(self.num_envs, device=self.device)
+    self.metrics["error_body_rot"] = torch.zeros(self.num_envs, device=self.device)
+    self.metrics["error_joint_pos"] = torch.zeros(self.num_envs, device=self.device)
+    self.metrics["error_joint_vel"] = torch.zeros(self.num_envs, device=self.device)
+    self.metrics["sampling_entropy"] = torch.zeros(self.num_envs, device=self.device)
+    self.metrics["sampling_top1_prob"] = torch.zeros(self.num_envs, device=self.device)
+    self.metrics["sampling_top1_bin"] = torch.zeros(self.num_envs, device=self.device)
+
+    self._ghost_model = None
+    self._ghost_color = np.array(cfg.viz.ghost_color, dtype=np.float32)
+    self._pending_forward = False
+
+  @property
+  def command(self) -> torch.Tensor:
+    return torch.cat([self.joint_pos, self.joint_vel], dim=1)
+
+  @property
+  def joint_pos(self) -> torch.Tensor:
+    return self.motion.joint_pos[self.time_steps]
+
+  @property
+  def joint_vel(self) -> torch.Tensor:
+    return self.motion.joint_vel[self.time_steps]
+
+  @property
+  def body_pos_w(self) -> torch.Tensor:
+    return (
+      self.motion.body_pos_w[self.time_steps] + self._env.scene.env_origins[:, None, :]
+    )
+
+  @property
+  def body_quat_w(self) -> torch.Tensor:
+    return self.motion.body_quat_w[self.time_steps]
+
+  @property
+  def body_lin_vel_w(self) -> torch.Tensor:
+    return self.motion.body_lin_vel_w[self.time_steps]
+
+  @property
+  def body_ang_vel_w(self) -> torch.Tensor:
+    return self.motion.body_ang_vel_w[self.time_steps]
+
+  @property
+  def anchor_pos_w(self) -> torch.Tensor:
+    return (
+      self.motion.body_pos_w[self.time_steps, self.motion_anchor_body_index]
+      + self._env.scene.env_origins
+    )
+
+  @property
+  def anchor_quat_w(self) -> torch.Tensor:
+    return self.motion.body_quat_w[self.time_steps, self.motion_anchor_body_index]
+
+  @property
+  def anchor_lin_vel_w(self) -> torch.Tensor:
+    return self.motion.body_lin_vel_w[self.time_steps, self.motion_anchor_body_index]
+
+  @property
+  def anchor_ang_vel_w(self) -> torch.Tensor:
+    return self.motion.body_ang_vel_w[self.time_steps, self.motion_anchor_body_index]
+
+  @property
+  def robot_joint_pos(self) -> torch.Tensor:
+    return self.robot.data.joint_pos
+
+  @property
+  def robot_joint_vel(self) -> torch.Tensor:
+    return self.robot.data.joint_vel
+
+  @property
+  def robot_body_pos_w(self) -> torch.Tensor:
+    return self.robot.data.body_link_pos_w[:, self.body_indexes]
+
+  @property
+  def robot_body_quat_w(self) -> torch.Tensor:
+    return self.robot.data.body_link_quat_w[:, self.body_indexes]
+
+  @property
+  def robot_body_lin_vel_w(self) -> torch.Tensor:
+    return self.robot.data.body_link_lin_vel_w[:, self.body_indexes]
+
+  @property
+  def robot_body_ang_vel_w(self) -> torch.Tensor:
+    return self.robot.data.body_link_ang_vel_w[:, self.body_indexes]
+
+  @property
+  def robot_anchor_pos_w(self) -> torch.Tensor:
+    return self.robot.data.body_link_pos_w[:, self.robot_anchor_body_index]
+
+  @property
+  def robot_anchor_quat_w(self) -> torch.Tensor:
+    return self.robot.data.body_link_quat_w[:, self.robot_anchor_body_index]
+
+  @property
+  def robot_anchor_lin_vel_w(self) -> torch.Tensor:
+    return self.robot.data.body_link_lin_vel_w[:, self.robot_anchor_body_index]
+
+  @property
+  def robot_anchor_ang_vel_w(self) -> torch.Tensor:
+    return self.robot.data.body_link_ang_vel_w[:, self.robot_anchor_body_index]
+
+  def _update_metrics(self):
+    self.metrics["error_anchor_pos"] = torch.norm(
+      self.anchor_pos_w - self.robot_anchor_pos_w, dim=-1
+    )
+    self.metrics["error_anchor_rot"] = quat_error_magnitude(
+      self.anchor_quat_w, self.robot_anchor_quat_w
+    )
+    self.metrics["error_anchor_lin_vel"] = torch.norm(
+      self.anchor_lin_vel_w - self.robot_anchor_lin_vel_w, dim=-1
+    )
+    self.metrics["error_anchor_ang_vel"] = torch.norm(
+      self.anchor_ang_vel_w - self.robot_anchor_ang_vel_w, dim=-1
+    )
+
+    self.metrics["error_body_pos"] = torch.norm(
+      self.body_pos_relative_w - self.robot_body_pos_w, dim=-1
+    ).mean(dim=-1)
+    self.metrics["error_body_rot"] = quat_error_magnitude(
+      self.body_quat_relative_w, self.robot_body_quat_w
+    ).mean(dim=-1)
+
+    self.metrics["error_body_lin_vel"] = torch.norm(
+      self.body_lin_vel_w - self.robot_body_lin_vel_w, dim=-1
+    ).mean(dim=-1)
+    self.metrics["error_body_ang_vel"] = torch.norm(
+      self.body_ang_vel_w - self.robot_body_ang_vel_w, dim=-1
+    ).mean(dim=-1)
+
+    self.metrics["error_joint_pos"] = torch.norm(
+      self.joint_pos - self.robot_joint_pos, dim=-1
+    )
+    self.metrics["error_joint_vel"] = torch.norm(
+      self.joint_vel - self.robot_joint_vel, dim=-1
+    )
+
+  def _adaptive_sampling(self, env_ids: torch.Tensor):
+    episode_failed = self._env.termination_manager.terminated[env_ids]
+    if torch.any(episode_failed):
+      current_bin_index = torch.clamp(
+        (self.time_steps * self.bin_count) // max(self.motion.time_step_total, 1),
+        0,
+        self.bin_count - 1,
+      )
+      fail_bins = current_bin_index[env_ids][episode_failed]
+      self._current_bin_failed[:] = torch.bincount(fail_bins, minlength=self.bin_count)
+
+    # Sample.
+    sampling_probabilities = (
+      self.bin_failed_count + self.cfg.adaptive_uniform_ratio / float(self.bin_count)
+    )
+    sampling_probabilities = torch.nn.functional.pad(
+      sampling_probabilities.unsqueeze(0).unsqueeze(0),
+      (0, self.cfg.adaptive_kernel_size - 1),  # Non-causal kernel
+      mode="replicate",
+    )
+    sampling_probabilities = torch.nn.functional.conv1d(
+      sampling_probabilities, self.kernel.view(1, 1, -1)
+    ).view(-1)
+
+    sampling_probabilities = sampling_probabilities / sampling_probabilities.sum()
+
+    sampled_bins = torch.multinomial(
+      sampling_probabilities, len(env_ids), replacement=True
+    )
+    self.time_steps[env_ids] = (
+      (sampled_bins + sample_uniform(0.0, 1.0, (len(env_ids),), device=self.device))
+      / self.bin_count
+      * (self.motion.time_step_total - 1)
+    ).long()
+
+    # Update metrics.
+    H = -(sampling_probabilities * (sampling_probabilities + 1e-12).log()).sum()
+    H_norm = H / math.log(self.bin_count) if self.bin_count > 1 else 1.0
+    pmax, imax = sampling_probabilities.max(dim=0)
+    self.metrics["sampling_entropy"][:] = H_norm
+    self.metrics["sampling_top1_prob"][:] = pmax
+    self.metrics["sampling_top1_bin"][:] = imax.float() / self.bin_count
+
+  def _uniform_sampling(self, env_ids: torch.Tensor):
+    self.time_steps[env_ids] = torch.randint(
+      0, self.motion.time_step_total, (len(env_ids),), device=self.device
+    )
+    self.metrics["sampling_entropy"][:] = 1.0  # Maximum entropy for uniform.
+    self.metrics["sampling_top1_prob"][:] = 1.0 / self.bin_count
+    self.metrics["sampling_top1_bin"][:] = 0.5  # No specific bin preference.
+
+  def _write_reference_state_to_sim(
+    self,
+    env_ids: torch.Tensor,
+    root_pos: torch.Tensor,
+    root_ori: torch.Tensor,
+    root_lin_vel: torch.Tensor,
+    root_ang_vel: torch.Tensor,
+    joint_pos: torch.Tensor,
+    joint_vel: torch.Tensor,
+  ) -> None:
+    """Clip joint positions and write root + joint state to sim."""
+    soft_limits = self.robot.data.soft_joint_pos_limits[env_ids]
+    joint_pos = torch.clip(joint_pos, soft_limits[:, :, 0], soft_limits[:, :, 1])
+    self.robot.write_joint_state_to_sim(joint_pos, joint_vel, env_ids=env_ids)
+
+    root_state = torch.cat([root_pos, root_ori, root_lin_vel, root_ang_vel], dim=-1)
+    self.robot.write_root_state_to_sim(root_state, env_ids=env_ids)
+    self.robot.reset(env_ids=env_ids)
+
+  def _resample_command(self, env_ids: torch.Tensor):
+    if self.cfg.sampling_mode == "start":
+      self.time_steps[env_ids] = 0
+    elif self.cfg.sampling_mode == "uniform":
+      self._uniform_sampling(env_ids)
+    else:
+      assert self.cfg.sampling_mode == "adaptive"
+      self._adaptive_sampling(env_ids)
+
+    root_pos = self.body_pos_w[env_ids, 0].clone()
+    root_ori = self.body_quat_w[env_ids, 0].clone()
+    root_lin_vel = self.body_lin_vel_w[env_ids, 0].clone()
+    root_ang_vel = self.body_ang_vel_w[env_ids, 0].clone()
+
+    range_list = [
+      self.cfg.pose_range.get(key, (0.0, 0.0))
+      for key in ["x", "y", "z", "roll", "pitch", "yaw"]
+    ]
+    ranges = torch.tensor(range_list, device=self.device)
+    rand_samples = sample_uniform(
+      ranges[:, 0], ranges[:, 1], (len(env_ids), 6), device=self.device
+    )
+    root_pos += rand_samples[:, 0:3]
+    orientations_delta = quat_from_euler_xyz(
+      rand_samples[:, 3], rand_samples[:, 4], rand_samples[:, 5]
+    )
+    root_ori = quat_mul(orientations_delta, root_ori)
+    range_list = [
+      self.cfg.velocity_range.get(key, (0.0, 0.0))
+      for key in ["x", "y", "z", "roll", "pitch", "yaw"]
+    ]
+    ranges = torch.tensor(range_list, device=self.device)
+    rand_samples = sample_uniform(
+      ranges[:, 0], ranges[:, 1], (len(env_ids), 6), device=self.device
+    )
+    root_lin_vel += rand_samples[:, :3]
+    root_ang_vel += rand_samples[:, 3:]
+
+    joint_pos = self.joint_pos[env_ids].clone()
+    joint_vel = self.joint_vel[env_ids]
+
+    joint_pos += sample_uniform(
+      lower=self.cfg.joint_position_range[0],
+      upper=self.cfg.joint_position_range[1],
+      size=joint_pos.shape,
+      device=joint_pos.device,  # type: ignore
+    )
+
+    self._write_reference_state_to_sim(
+      env_ids,
+      root_pos,
+      root_ori,
+      root_lin_vel,
+      root_ang_vel,
+      joint_pos,
+      joint_vel,
+    )
+    self._pending_forward = True
+
+  def update_relative_body_poses(self) -> None:
+    """Recompute ``body_pos_relative_w`` and ``body_quat_relative_w``.
+
+    Called after ``reset_to_frame`` so that termination checks that
+    compare relative body positions see the correct state.
+    """
+    anchor_pos_w_repeat = self.anchor_pos_w[:, None, :].repeat(
+      1, len(self.cfg.body_names), 1
+    )
+    anchor_quat_w_repeat = self.anchor_quat_w[:, None, :].repeat(
+      1, len(self.cfg.body_names), 1
+    )
+    robot_anchor_pos_w_repeat = self.robot_anchor_pos_w[:, None, :].repeat(
+      1, len(self.cfg.body_names), 1
+    )
+    robot_anchor_quat_w_repeat = self.robot_anchor_quat_w[:, None, :].repeat(
+      1, len(self.cfg.body_names), 1
+    )
+
+    delta_pos_w = robot_anchor_pos_w_repeat
+    delta_pos_w[..., 2] = anchor_pos_w_repeat[..., 2]
+    delta_ori_w = yaw_quat(
+      quat_mul(robot_anchor_quat_w_repeat, quat_inv(anchor_quat_w_repeat))
+    )
+
+    self.body_quat_relative_w = quat_mul(delta_ori_w, self.body_quat_w)
+    self.body_pos_relative_w = delta_pos_w + quat_apply(
+      delta_ori_w, self.body_pos_w - anchor_pos_w_repeat
+    )
+
+  def reset(self, env_ids: torch.Tensor | slice | None) -> dict[str, float]:
+    extras = super().reset(env_ids)
+    # Reset-path resamples are followed by the env's own forward(); only
+    # compute-path resamples (wraparound or timer expiry) need our refresh.
+    self._pending_forward = False
+    return extras
+
+  def _update_command(self, env_ids: torch.Tensor | None = None):
+    if env_ids is None:
+      self.time_steps += 1
+    else:
+      self.time_steps[env_ids] += 1
+    wrap_ids = torch.where(self.time_steps >= self.motion.time_step_total)[0]
+    if wrap_ids.numel() > 0:
+      self._resample_command(wrap_ids)
+
+    # _resample_command writes qpos/qvel but does not refresh derived
+    # quantities; forward() so update_relative_body_poses reads the
+    # post-teleport robot anchor instead of the stale pre-resample pose.
+    # Covers both the wraparound above and a timer-expiry resample that ran
+    # in compute before this call.
+    if self._pending_forward:
+      self._pending_forward = False
+      self._env.sim.forward()
+
+    self.update_relative_body_poses()
+
+    # Fold failure counts into the EMA only on the per-step update so
+    # manual resets do not decay it faster.
+    if env_ids is None and self.cfg.sampling_mode == "adaptive":
+      self.bin_failed_count = (
+        self.cfg.adaptive_alpha * self._current_bin_failed
+        + (1 - self.cfg.adaptive_alpha) * self.bin_failed_count
+      )
+      self._current_bin_failed.zero_()
+
+  def _debug_vis_impl(self, visualizer: DebugVisualizer) -> None:
+    """Draw ghost robot or frames based on visualization mode."""
+    env_indices = visualizer.get_env_indices(self.num_envs)
+    if not env_indices:
+      return
+
+    if self.cfg.viz.mode == "ghost":
+      if self._ghost_model is None:
+        # Build a ghost model with only visual geoms visible. Collision geoms (nonzero
+        # contype/conaffinity) get alpha=0 so the viewer's alpha filter excludes them.
+        self._ghost_model = copy.deepcopy(self._env.sim.mj_model)
+        for gi in range(self._ghost_model.ngeom):
+          if (
+            self._ghost_model.geom_contype[gi] != 0
+            or self._ghost_model.geom_conaffinity[gi] != 0
+          ):
+            self._ghost_model.geom_rgba[gi, 3] = 0
+          else:
+            self._ghost_model.geom_rgba[gi] = self._ghost_color
+
+      entity: Entity = self._env.scene[self.cfg.entity_name]
+      indexing = entity.indexing
+      free_joint_q_adr = indexing.free_joint_q_adr.cpu().numpy()
+      joint_q_adr = indexing.joint_q_adr.cpu().numpy()
+
+      for batch in env_indices:
+        qpos = np.zeros(self._env.sim.mj_model.nq)
+        qpos[free_joint_q_adr[0:3]] = self.body_pos_w[batch, 0].cpu().numpy()
+        qpos[free_joint_q_adr[3:7]] = self.body_quat_w[batch, 0].cpu().numpy()
+        qpos[joint_q_adr] = self.joint_pos[batch].cpu().numpy()
+
+        visualizer.add_ghost_mesh(
+          qpos,
+          model=self._ghost_model,
+          label=f"ghost_{batch}",
+        )
+
+    elif self.cfg.viz.mode == "frames":
+      for batch in env_indices:
+        desired_body_pos = self.body_pos_w[batch].cpu().numpy()
+        desired_body_quat = self.body_quat_w[batch]
+        desired_body_rotm = matrix_from_quat(desired_body_quat).cpu().numpy()
+
+        current_body_pos = self.robot_body_pos_w[batch].cpu().numpy()
+        current_body_quat = self.robot_body_quat_w[batch]
+        current_body_rotm = matrix_from_quat(current_body_quat).cpu().numpy()
+
+        for i, body_name in enumerate(self.cfg.body_names):
+          visualizer.add_frame(
+            position=desired_body_pos[i],
+            rotation_matrix=desired_body_rotm[i],
+            scale=0.08,
+            label=f"desired_{body_name}_{batch}",
+            axis_colors=_DESIRED_FRAME_COLORS,
+          )
+          visualizer.add_frame(
+            position=current_body_pos[i],
+            rotation_matrix=current_body_rotm[i],
+            scale=0.12,
+            label=f"current_{body_name}_{batch}",
+          )
+
+        desired_anchor_pos = self.anchor_pos_w[batch].cpu().numpy()
+        desired_anchor_quat = self.anchor_quat_w[batch]
+        desired_rotation_matrix = matrix_from_quat(desired_anchor_quat).cpu().numpy()
+        visualizer.add_frame(
+          position=desired_anchor_pos,
+          rotation_matrix=desired_rotation_matrix,
+          scale=0.1,
+          label=f"desired_anchor_{batch}",
+          axis_colors=_DESIRED_FRAME_COLORS,
+        )
+
+        current_anchor_pos = self.robot_anchor_pos_w[batch].cpu().numpy()
+        current_anchor_quat = self.robot_anchor_quat_w[batch]
+        current_rotation_matrix = matrix_from_quat(current_anchor_quat).cpu().numpy()
+        visualizer.add_frame(
+          position=current_anchor_pos,
+          rotation_matrix=current_rotation_matrix,
+          scale=0.15,
+          label=f"current_anchor_{batch}",
+        )
+
+  def create_gui(
+    self,
+    name: str,
+    server: viser.ViserServer,
+    get_env_idx: Callable[[], int],
+    on_change: Callable[[], None] | None = None,
+    request_action: Callable[[str, Any], None] | None = None,
+  ) -> None:
+    """Create motion scrubber controls in the Viser viewer."""
+    max_frame = int(self.motion.time_step_total) - 1
+
+    with server.gui.add_folder(name.capitalize()):
+      scrubber = server.gui.add_slider(
+        "Frame",
+        min=0,
+        max=max_frame,
+        step=1,
+        initial_value=0,
+      )
+
+      @scrubber.on_update
+      def _(_) -> None:
+        idx = get_env_idx()
+        self.time_steps[idx] = int(scrubber.value)
+        if on_change is not None:
+          on_change()
+
+      all_envs_cb = server.gui.add_checkbox("All envs", initial_value=True)
+      start_btn = server.gui.add_button("Start Here")
+
+      @start_btn.on_click
+      def _(_) -> None:
+        if request_action is not None:
+          request_action(
+            "CUSTOM",
+            {"type": "gui_reset", "all_envs": all_envs_cb.value},
+          )
+
+    self._scrubber_handles = (scrubber, all_envs_cb, start_btn)
+    self._set_scrubber_disabled(True)
+
+  def _set_scrubber_disabled(self, disabled: bool) -> None:
+    """Enable or disable the motion scrubber GUI controls."""
+    for handle in self._scrubber_handles:
+      handle.disabled = disabled
+
+  def on_viewer_pause(self, paused: bool) -> None:
+    if hasattr(self, "_scrubber_handles"):
+      self._set_scrubber_disabled(not paused)
+
+  def apply_gui_reset(self, env_ids: torch.Tensor) -> bool:
+    if not hasattr(self, "_scrubber_handles"):
+      return False
+    frame = int(self._scrubber_handles[0].value)
+    self.reset_to_frame(env_ids, frame)
+    # reset_to_frame writes qpos/qvel; forward so update_relative_body_poses
+    # reads the scrubbed pose instead of the stale pre-scrub kinematics.
+    self._env.sim.forward()
+    self.update_relative_body_poses()
+    return True
+
+  def reset_to_frame(self, env_ids: torch.Tensor, frame: int) -> None:
+    """Reset to exact reference state at a specific frame.
+
+    Like ``_resample_command`` but deterministic: no random
+    perturbations to pose, velocity, or joint positions.
+    """
+    self.time_steps[env_ids] = frame
+    self._write_reference_state_to_sim(
+      env_ids,
+      self.body_pos_w[env_ids, 0],
+      self.body_quat_w[env_ids, 0],
+      self.body_lin_vel_w[env_ids, 0],
+      self.body_ang_vel_w[env_ids, 0],
+      self.joint_pos[env_ids],
+      self.joint_vel[env_ids],
+    )
+
+
+@dataclass(kw_only=True)
+class MotionCommandCfg(CommandTermCfg):
+  motion_file: str
+  anchor_body_name: str
+  body_names: tuple[str, ...]
+  entity_name: str
+  pose_range: dict[str, tuple[float, float]] = field(default_factory=dict)
+  velocity_range: dict[str, tuple[float, float]] = field(default_factory=dict)
+  joint_position_range: tuple[float, float] = (-0.52, 0.52)
+  adaptive_kernel_size: int = 1
+  adaptive_lambda: float = 0.8
+  adaptive_uniform_ratio: float = 0.1
+  adaptive_alpha: float = 0.001
+  sampling_mode: Literal["adaptive", "uniform", "start"] = "adaptive"
+
+  @dataclass
+  class VizCfg:
+    mode: Literal["ghost", "frames"] = "ghost"
+    ghost_color: tuple[float, float, float, float] = (0.5, 0.7, 0.5, 0.5)
+
+  viz: VizCfg = field(default_factory=VizCfg)
+
+  def build(self, env: ManagerBasedRlEnv) -> MotionCommand:
+    return MotionCommand(self, env)
diff --git a/src/mjlab/tasks/tracking/mdp/metrics.py b/src/mjlab/tasks/tracking/mdp/metrics.py
new file mode 100644
index 0000000..eb5fe9f
--- /dev/null
+++ b/src/mjlab/tasks/tracking/mdp/metrics.py
@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.utils.lab_api.math import quat_error_magnitude
+
+if TYPE_CHECKING:
+  from mjlab.tasks.tracking.mdp.commands import MotionCommand
+
+
+def compute_mpkpe(command: MotionCommand) -> torch.Tensor:
+  """Compute Mean Per-Keybody Position Error (MPKPE).
+
+  MPKPE measures the average Euclidean distance between the reference and
+  actual key body positions in the global world frame. It captures all
+  tracking error, including global translation and heading drift.
+  """
+  pos_error = command.body_pos_w - command.robot_body_pos_w
+  per_body_error = torch.norm(pos_error, dim=-1)  # (num_envs, num_bodies)
+  return per_body_error.mean(dim=-1)  # (num_envs,)
+
+
+def compute_root_relative_mpkpe(command: MotionCommand) -> torch.Tensor:
+  """Compute Root-relative Mean Per-Keybody Position Error (R-MPKPE).
+
+  R-MPKPE measures intrinsic pose error independent of global drift. It
+  uses ``body_pos_relative_w``, the reference re-anchored to the robot's
+  current root position and heading each step (the same quantity the
+  tracking reward optimizes), so both global translation and yaw drift are
+  removed and only the local body pose error remains.
+  """
+  pos_error = command.body_pos_relative_w - command.robot_body_pos_w
+  per_body_error = torch.norm(pos_error, dim=-1)  # (num_envs, num_bodies)
+  return per_body_error.mean(dim=-1)  # (num_envs,)
+
+
+def compute_joint_velocity_error(command: MotionCommand) -> torch.Tensor:
+  """Compute root-mean-square joint velocity error.
+
+  Uses an RMS over joints (rather than a raw L2 norm) so the value is a
+  per-joint quantity, comparable across robots with different DOF counts.
+  """
+  vel_error = command.joint_vel - command.robot_joint_vel
+  return torch.sqrt(torch.mean(vel_error**2, dim=-1))  # (num_envs,)
+
+
+def compute_ee_position_error(
+  command: MotionCommand,
+  ee_body_names: tuple[str, ...],
+) -> torch.Tensor:
+  """Compute end effector position error."""
+  ee_indices = _get_body_indices(command, ee_body_names)
+  if len(ee_indices) == 0:
+    return torch.zeros(command.num_envs, device=command.device)
+
+  ref_ee_pos = command.body_pos_relative_w[:, ee_indices]
+  robot_ee_pos = command.robot_body_pos_w[:, ee_indices]
+
+  pos_error = ref_ee_pos - robot_ee_pos
+  per_ee_error = torch.norm(pos_error, dim=-1)  # (num_envs, num_ee)
+  return per_ee_error.mean(dim=-1)  # (num_envs,)
+
+
+def compute_ee_orientation_error(
+  command: MotionCommand,
+  ee_body_names: tuple[str, ...],
+) -> torch.Tensor:
+  """Compute end effector orientation error."""
+  ee_indices = _get_body_indices(command, ee_body_names)
+  if len(ee_indices) == 0:
+    return torch.zeros(command.num_envs, device=command.device)
+
+  ref_ee_quat = command.body_quat_relative_w[:, ee_indices]
+  robot_ee_quat = command.robot_body_quat_w[:, ee_indices]
+
+  per_ee_error = quat_error_magnitude(ref_ee_quat, robot_ee_quat)  # (num_envs, num_ee)
+  return per_ee_error.mean(dim=-1)  # (num_envs,)
+
+
+def _get_body_indices(
+  command: MotionCommand,
+  body_names: tuple[str, ...],
+) -> list[int]:
+  """Get indices of specified bodies within the command's body list.
+
+  Args:
+    command: The motion command.
+    body_names: Names of bodies to find.
+
+  Returns:
+    List of indices into command.cfg.body_names, in the order requested.
+
+  Raises:
+    ValueError: If any requested body name is not tracked by the command.
+      Silently dropping unknown names would otherwise report a spurious
+      zero error for misconfigured end-effector lists.
+  """
+  name_to_index = {name: i for i, name in enumerate(command.cfg.body_names)}
+  missing = [name for name in body_names if name not in name_to_index]
+  if missing:
+    raise ValueError(
+      f"Body names {missing} are not tracked by the command. "
+      f"Available bodies: {tuple(command.cfg.body_names)}."
+    )
+  return [name_to_index[name] for name in body_names]
diff --git a/src/mjlab/tasks/tracking/mdp/observations.py b/src/mjlab/tasks/tracking/mdp/observations.py
new file mode 100644
index 0000000..93df197
--- /dev/null
+++ b/src/mjlab/tasks/tracking/mdp/observations.py
@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+import torch
+
+from mjlab.utils.lab_api.math import (
+  matrix_from_quat,
+  subtract_frame_transforms,
+)
+
+from .commands import MotionCommand
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+def motion_anchor_pos_b(env: ManagerBasedRlEnv, command_name: str) -> torch.Tensor:
+  command = cast(MotionCommand, env.command_manager.get_term(command_name))
+
+  pos, _ = subtract_frame_transforms(
+    command.robot_anchor_pos_w,
+    command.robot_anchor_quat_w,
+    command.anchor_pos_w,
+    command.anchor_quat_w,
+  )
+
+  return pos.view(env.num_envs, -1)
+
+
+def motion_anchor_ori_b(env: ManagerBasedRlEnv, command_name: str) -> torch.Tensor:
+  command = cast(MotionCommand, env.command_manager.get_term(command_name))
+
+  _, ori = subtract_frame_transforms(
+    command.robot_anchor_pos_w,
+    command.robot_anchor_quat_w,
+    command.anchor_pos_w,
+    command.anchor_quat_w,
+  )
+  mat = matrix_from_quat(ori)
+  return mat[..., :2].reshape(mat.shape[0], -1)
+
+
+def robot_body_pos_b(env: ManagerBasedRlEnv, command_name: str) -> torch.Tensor:
+  command = cast(MotionCommand, env.command_manager.get_term(command_name))
+
+  num_bodies = len(command.cfg.body_names)
+  pos_b, _ = subtract_frame_transforms(
+    command.robot_anchor_pos_w[:, None, :].repeat(1, num_bodies, 1),
+    command.robot_anchor_quat_w[:, None, :].repeat(1, num_bodies, 1),
+    command.robot_body_pos_w,
+    command.robot_body_quat_w,
+  )
+
+  return pos_b.view(env.num_envs, -1)
+
+
+def robot_body_ori_b(env: ManagerBasedRlEnv, command_name: str) -> torch.Tensor:
+  command = cast(MotionCommand, env.command_manager.get_term(command_name))
+
+  num_bodies = len(command.cfg.body_names)
+  _, ori_b = subtract_frame_transforms(
+    command.robot_anchor_pos_w[:, None, :].repeat(1, num_bodies, 1),
+    command.robot_anchor_quat_w[:, None, :].repeat(1, num_bodies, 1),
+    command.robot_body_pos_w,
+    command.robot_body_quat_w,
+  )
+  mat = matrix_from_quat(ori_b)
+  return mat[..., :2].reshape(mat.shape[0], -1)
diff --git a/src/mjlab/tasks/tracking/mdp/rewards.py b/src/mjlab/tasks/tracking/mdp/rewards.py
new file mode 100644
index 0000000..341e01a
--- /dev/null
+++ b/src/mjlab/tasks/tracking/mdp/rewards.py
@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+import torch
+
+from mjlab.sensor import ContactSensor
+from mjlab.utils.lab_api.math import quat_error_magnitude
+
+from .commands import MotionCommand
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+def _get_body_indexes(
+  command: MotionCommand, body_names: tuple[str, ...] | None
+) -> list[int]:
+  return [
+    i
+    for i, name in enumerate(command.cfg.body_names)
+    if (body_names is None) or (name in body_names)
+  ]
+
+
+def motion_global_anchor_position_error_exp(
+  env: ManagerBasedRlEnv, command_name: str, std: float
+) -> torch.Tensor:
+  command = cast(MotionCommand, env.command_manager.get_term(command_name))
+  error = torch.sum(
+    torch.square(command.anchor_pos_w - command.robot_anchor_pos_w), dim=-1
+  )
+  return torch.exp(-error / std**2)
+
+
+def motion_global_anchor_orientation_error_exp(
+  env: ManagerBasedRlEnv, command_name: str, std: float
+) -> torch.Tensor:
+  command = cast(MotionCommand, env.command_manager.get_term(command_name))
+  error = quat_error_magnitude(command.anchor_quat_w, command.robot_anchor_quat_w) ** 2
+  return torch.exp(-error / std**2)
+
+
+def motion_relative_body_position_error_exp(
+  env: ManagerBasedRlEnv,
+  command_name: str,
+  std: float,
+  body_names: tuple[str, ...] | None = None,
+) -> torch.Tensor:
+  command = cast(MotionCommand, env.command_manager.get_term(command_name))
+  body_indexes = _get_body_indexes(command, body_names)
+  error = torch.sum(
+    torch.square(
+      command.body_pos_relative_w[:, body_indexes]
+      - command.robot_body_pos_w[:, body_indexes]
+    ),
+    dim=-1,
+  )
+  return torch.exp(-error.mean(-1) / std**2)
+
+
+def motion_relative_body_orientation_error_exp(
+  env: ManagerBasedRlEnv,
+  command_name: str,
+  std: float,
+  body_names: tuple[str, ...] | None = None,
+) -> torch.Tensor:
+  command = cast(MotionCommand, env.command_manager.get_term(command_name))
+  body_indexes = _get_body_indexes(command, body_names)
+  error = (
+    quat_error_magnitude(
+      command.body_quat_relative_w[:, body_indexes],
+      command.robot_body_quat_w[:, body_indexes],
+    )
+    ** 2
+  )
+  return torch.exp(-error.mean(-1) / std**2)
+
+
+def motion_global_body_linear_velocity_error_exp(
+  env: ManagerBasedRlEnv,
+  command_name: str,
+  std: float,
+  body_names: tuple[str, ...] | None = None,
+) -> torch.Tensor:
+  command = cast(MotionCommand, env.command_manager.get_term(command_name))
+  body_indexes = _get_body_indexes(command, body_names)
+  error = torch.sum(
+    torch.square(
+      command.body_lin_vel_w[:, body_indexes]
+      - command.robot_body_lin_vel_w[:, body_indexes]
+    ),
+    dim=-1,
+  )
+  return torch.exp(-error.mean(-1) / std**2)
+
+
+def motion_global_body_angular_velocity_error_exp(
+  env: ManagerBasedRlEnv,
+  command_name: str,
+  std: float,
+  body_names: tuple[str, ...] | None = None,
+) -> torch.Tensor:
+  command = cast(MotionCommand, env.command_manager.get_term(command_name))
+  body_indexes = _get_body_indexes(command, body_names)
+  error = torch.sum(
+    torch.square(
+      command.body_ang_vel_w[:, body_indexes]
+      - command.robot_body_ang_vel_w[:, body_indexes]
+    ),
+    dim=-1,
+  )
+  return torch.exp(-error.mean(-1) / std**2)
+
+
+def self_collision_cost(
+  env: ManagerBasedRlEnv,
+  sensor_name: str,
+  force_threshold: float = 10.0,
+) -> torch.Tensor:
+  """Penalize self-collisions.
+
+  When the sensor provides force history (from ``history_length > 0``),
+  counts substeps where any contact force exceeds *force_threshold*.
+  Falls back to the instantaneous ``found`` count otherwise.
+  """
+  sensor: ContactSensor = env.scene[sensor_name]
+  data = sensor.data
+  if data.force_history is not None:
+    # force_history: [B, N, H, 3]
+    force_mag = torch.norm(data.force_history, dim=-1)  # [B, N, H]
+    hit = (force_mag > force_threshold).any(dim=1)  # [B, H]
+    return hit.sum(dim=-1).float()  # [B]
+  assert data.found is not None
+  return data.found.squeeze(-1)
diff --git a/src/mjlab/tasks/tracking/mdp/terminations.py b/src/mjlab/tasks/tracking/mdp/terminations.py
new file mode 100644
index 0000000..62d4452
--- /dev/null
+++ b/src/mjlab/tasks/tracking/mdp/terminations.py
@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+import torch
+
+from mjlab.utils.lab_api.math import quat_apply_inverse
+
+from .commands import MotionCommand
+from .rewards import _get_body_indexes
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+  from mjlab.envs import ManagerBasedRlEnv
+  from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+
+def bad_anchor_pos(
+  env: ManagerBasedRlEnv, command_name: str, threshold: float
+) -> torch.Tensor:
+  command = cast(MotionCommand, env.command_manager.get_term(command_name))
+  return (
+    torch.norm(command.anchor_pos_w - command.robot_anchor_pos_w, dim=1) > threshold
+  )
+
+
+def bad_anchor_pos_z_only(
+  env: ManagerBasedRlEnv, command_name: str, threshold: float
+) -> torch.Tensor:
+  command = cast(MotionCommand, env.command_manager.get_term(command_name))
+  return (
+    torch.abs(command.anchor_pos_w[:, -1] - command.robot_anchor_pos_w[:, -1])
+    > threshold
+  )
+
+
+def bad_anchor_ori(
+  env: ManagerBasedRlEnv, asset_cfg: SceneEntityCfg, command_name: str, threshold: float
+) -> torch.Tensor:
+  asset: Entity = env.scene[asset_cfg.name]
+
+  command = cast(MotionCommand, env.command_manager.get_term(command_name))
+  motion_projected_gravity_b = quat_apply_inverse(
+    command.anchor_quat_w, asset.data.gravity_vec_w
+  )
+
+  robot_projected_gravity_b = quat_apply_inverse(
+    command.robot_anchor_quat_w, asset.data.gravity_vec_w
+  )
+
+  return (
+    motion_projected_gravity_b[:, 2] - robot_projected_gravity_b[:, 2]
+  ).abs() > threshold
+
+
+def bad_motion_body_pos(
+  env: ManagerBasedRlEnv,
+  command_name: str,
+  threshold: float,
+  body_names: tuple[str, ...] | None = None,
+) -> torch.Tensor:
+  command = cast(MotionCommand, env.command_manager.get_term(command_name))
+
+  body_indexes = _get_body_indexes(command, body_names)
+  error = torch.norm(
+    command.body_pos_relative_w[:, body_indexes]
+    - command.robot_body_pos_w[:, body_indexes],
+    dim=-1,
+  )
+  return torch.any(error > threshold, dim=-1)
+
+
+def bad_motion_body_pos_z_only(
+  env: ManagerBasedRlEnv,
+  command_name: str,
+  threshold: float,
+  body_names: tuple[str, ...] | None = None,
+) -> torch.Tensor:
+  command = cast(MotionCommand, env.command_manager.get_term(command_name))
+
+  body_indexes = _get_body_indexes(command, body_names)
+  error = torch.abs(
+    command.body_pos_relative_w[:, body_indexes, -1]
+    - command.robot_body_pos_w[:, body_indexes, -1]
+  )
+  return torch.any(error > threshold, dim=-1)
diff --git a/src/mjlab/tasks/tracking/rl/__init__.py b/src/mjlab/tasks/tracking/rl/__init__.py
new file mode 100644
index 0000000..f4da6f2
--- /dev/null
+++ b/src/mjlab/tasks/tracking/rl/__init__.py
@@ -0,0 +1,3 @@
+from mjlab.tasks.tracking.rl.runner import (
+  MotionTrackingOnPolicyRunner as MotionTrackingOnPolicyRunner,
+)
diff --git a/src/mjlab/tasks/tracking/rl/runner.py b/src/mjlab/tasks/tracking/rl/runner.py
new file mode 100644
index 0000000..f20ff39
--- /dev/null
+++ b/src/mjlab/tasks/tracking/rl/runner.py
@@ -0,0 +1,117 @@
+import os
+from typing import cast
+
+import torch
+import wandb
+from rsl_rl.env.vec_env import VecEnv
+from rsl_rl.utils import WandbLogWriter
+from torch import nn
+
+from mjlab.rl import RslRlVecEnvWrapper
+from mjlab.rl.exporter_utils import (
+  attach_metadata_to_onnx,
+  get_base_metadata,
+)
+from mjlab.rl.runner import MjlabOnPolicyRunner
+from mjlab.tasks.tracking.mdp import MotionCommand
+
+
+class _OnnxMotionModel(nn.Module):
+  """ONNX-exportable model that wraps the policy and bundles motion reference data."""
+
+  def __init__(self, actor, motion):
+    super().__init__()
+    self.policy = actor.as_onnx(verbose=False)
+    self.register_buffer("joint_pos", motion.joint_pos.to("cpu"))
+    self.register_buffer("joint_vel", motion.joint_vel.to("cpu"))
+    self.register_buffer("body_pos_w", motion.body_pos_w.to("cpu"))
+    self.register_buffer("body_quat_w", motion.body_quat_w.to("cpu"))
+    self.register_buffer("body_lin_vel_w", motion.body_lin_vel_w.to("cpu"))
+    self.register_buffer("body_ang_vel_w", motion.body_ang_vel_w.to("cpu"))
+    self.time_step_total: int = self.joint_pos.shape[0]  # type: ignore[index]
+
+  def forward(self, x, time_step):
+    time_step_clamped = torch.clamp(
+      time_step.long().squeeze(-1), max=self.time_step_total - 1
+    )
+    return (
+      self.policy(x),
+      self.joint_pos[time_step_clamped],  # type: ignore[index]
+      self.joint_vel[time_step_clamped],  # type: ignore[index]
+      self.body_pos_w[time_step_clamped],  # type: ignore[index]
+      self.body_quat_w[time_step_clamped],  # type: ignore[index]
+      self.body_lin_vel_w[time_step_clamped],  # type: ignore[index]
+      self.body_ang_vel_w[time_step_clamped],  # type: ignore[index]
+    )
+
+
+class MotionTrackingOnPolicyRunner(MjlabOnPolicyRunner):
+  env: RslRlVecEnvWrapper
+
+  def __init__(
+    self,
+    env: VecEnv,
+    train_cfg: dict,
+    log_dir: str | None = None,
+    device: str = "cpu",
+    registry_name: str | None = None,
+  ):
+    super().__init__(env, train_cfg, log_dir, device)
+    self.registry_name = registry_name
+
+  def export_policy_to_onnx(
+    self, path: str, filename: str = "policy.onnx", verbose: bool = False
+  ) -> None:
+    os.makedirs(path, exist_ok=True)
+    cmd = cast(MotionCommand, self.env.unwrapped.command_manager.get_term("motion"))
+    model = _OnnxMotionModel(self.alg.get_policy(), cmd.motion)
+    model.to("cpu")
+    model.eval()
+    obs = torch.zeros(1, model.policy.input_size)
+    time_step = torch.zeros(1, 1)
+    torch.onnx.export(
+      model,
+      (obs, time_step),
+      os.path.join(path, filename),
+      export_params=True,
+      opset_version=18,
+      verbose=verbose,
+      input_names=["obs", "time_step"],
+      output_names=[
+        "actions",
+        "joint_pos",
+        "joint_vel",
+        "body_pos_w",
+        "body_quat_w",
+        "body_lin_vel_w",
+        "body_ang_vel_w",
+      ],
+      dynamic_axes={},
+      dynamo=False,
+    )
+
+  def save(self, path: str, infos=None):
+    super().save(path, infos)
+    policy_dir, filename, onnx_path = self._get_export_paths(path)
+    try:
+      self.export_policy_to_onnx(str(policy_dir), filename)
+      is_wandb = isinstance(self.logger.writer, WandbLogWriter)
+      run_name: str = wandb.run.name if is_wandb and wandb.run else "local"  # type: ignore[assignment]
+      metadata = get_base_metadata(self.env.unwrapped, run_name)
+      motion_term = cast(
+        MotionCommand, self.env.unwrapped.command_manager.get_term("motion")
+      )
+      metadata.update(
+        {
+          "anchor_body_name": motion_term.cfg.anchor_body_name,
+          "body_names": list(motion_term.cfg.body_names),
+        }
+      )
+      attach_metadata_to_onnx(str(onnx_path), metadata)
+      if is_wandb and self.cfg["upload_model"]:
+        wandb.save(str(onnx_path), base_path=str(policy_dir))
+        if self.registry_name is not None:
+          wandb.run.use_artifact(self.registry_name)  # type: ignore
+          self.registry_name = None
+    except Exception as e:
+      print(f"[WARN] ONNX export failed (training continues): {e}")
diff --git a/src/mjlab/tasks/tracking/scripts/evaluate.py b/src/mjlab/tasks/tracking/scripts/evaluate.py
new file mode 100644
index 0000000..597d3ab
--- /dev/null
+++ b/src/mjlab/tasks/tracking/scripts/evaluate.py
@@ -0,0 +1,237 @@
+"""Evaluate a trained tracking policy and compute metrics."""
+
+from __future__ import annotations
+
+import json
+import sys
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from types import SimpleNamespace
+from typing import cast
+
+import torch
+import tyro
+import wandb
+
+from mjlab.envs import ManagerBasedRlEnv
+from mjlab.rl import MjlabOnPolicyRunner, RslRlVecEnvWrapper
+from mjlab.tasks.registry import list_tasks, load_env_cfg, load_rl_cfg, load_runner_cls
+from mjlab.tasks.tracking.mdp import MotionCommandCfg
+from mjlab.tasks.tracking.mdp.commands import MotionCommand
+from mjlab.tasks.tracking.mdp.metrics import (
+  compute_ee_orientation_error,
+  compute_ee_position_error,
+  compute_joint_velocity_error,
+  compute_mpkpe,
+  compute_root_relative_mpkpe,
+)
+from mjlab.utils.os import get_wandb_checkpoint_path
+from mjlab.utils.torch import configure_torch_backends
+
+
+@dataclass(frozen=True)
+class EvaluateConfig:
+  """Configuration for policy evaluation."""
+
+  wandb_run_path: str
+  """W&B run path in format 'entity/project/run_id'."""
+  wandb_checkpoint_name: str | None = None
+  """Optional checkpoint name within the W&B run to load (e.g. 'model_4000.pt')."""
+  num_envs: int = 1024
+  """Number of parallel environments (= number of episodes to evaluate)."""
+  device: str | None = None
+  """Device to run on. Defaults to CUDA if available."""
+  output_file: str | None = None
+  """Optional path to save metrics as JSON."""
+  log_root: str = "logs/rsl_rl"
+  """Root directory under which experiment logs are written."""
+
+
+def run_evaluate(task_id: str, cfg: EvaluateConfig) -> dict[str, float]:
+  """Run policy evaluation and compute metrics."""
+  configure_torch_backends()
+  device = cfg.device or ("cuda:0" if torch.cuda.is_available() else "cpu")
+
+  # Load configs.
+  env_cfg = load_env_cfg(task_id, play=False)
+  agent_cfg = load_rl_cfg(task_id)
+
+  motion_cmd = env_cfg.commands.get("motion")
+  if not isinstance(motion_cmd, MotionCommandCfg):
+    raise ValueError(f"Task {task_id} is not a tracking task.")
+
+  # Load motion file from W&B run.
+  api = wandb.Api()
+  run = api.run(cfg.wandb_run_path)
+  art = next((a for a in run.used_artifacts() if a.type == "motions"), None)
+  if art is None:
+    raise RuntimeError("No motion artifact found in the run.")
+  motion_cmd.motion_file = str(Path(art.download()) / "motion.npz")
+
+  # Evaluation config.
+  motion_cmd.sampling_mode = "start"
+  env_cfg.observations["actor"].enable_corruption = True
+  env_cfg.events.pop("push_robot", None)
+  env_cfg.scene.num_envs = cfg.num_envs
+
+  env = ManagerBasedRlEnv(cfg=env_cfg, device=device)
+  env = RslRlVecEnvWrapper(env, clip_actions=agent_cfg.clip_actions)
+
+  log_root_path = (Path(cfg.log_root) / agent_cfg.experiment_name).resolve()
+  resume_path, _ = get_wandb_checkpoint_path(
+    log_root_path, Path(cfg.wandb_run_path), cfg.wandb_checkpoint_name
+  )
+  print(f"[INFO] Loading checkpoint: {resume_path}")
+
+  runner_cls = load_runner_cls(task_id) or MjlabOnPolicyRunner
+  runner = runner_cls(env, asdict(agent_cfg), device=device)
+  runner.load(str(resume_path), map_location=device)
+  policy = runner.get_inference_policy(device=device)
+
+  command = cast(MotionCommand, env.unwrapped.command_manager.get_term("motion"))
+  ee_body_names = env_cfg.terminations["ee_body_pos"].params["body_names"]
+  print(f"[INFO] End effector bodies: {ee_body_names}")
+
+  # Metric accumulators.
+  all_mpkpe: list[torch.Tensor] = []
+  all_r_mpkpe: list[torch.Tensor] = []
+  all_joint_vel_error: list[torch.Tensor] = []
+  all_ee_pos_error: list[torch.Tensor] = []
+  all_ee_ori_error: list[torch.Tensor] = []
+  all_active: list[torch.Tensor] = []
+
+  done_envs = torch.zeros(cfg.num_envs, dtype=torch.bool, device=device)
+  success = torch.zeros(cfg.num_envs, dtype=torch.bool, device=device)
+
+  obs = env.get_observations()
+
+  print(f"[INFO] Running {cfg.num_envs} evaluation episodes...")
+
+  step = 0
+  while not done_envs.all():
+    # Snapshot the reference frame the upcoming step will be scored against.
+    # env.step computes the reward (against the current reference) and only
+    # afterwards advances the command's motion frame, so reading the
+    # reference after stepping would pair the robot with the *next* frame.
+    # We snapshot here and pair it with the post-step robot state below,
+    # matching how the reward is computed.
+    ref = SimpleNamespace(
+      num_envs=command.num_envs,
+      device=command.device,
+      cfg=command.cfg,
+      body_pos_w=command.body_pos_w.clone(),
+      body_pos_relative_w=command.body_pos_relative_w.clone(),
+      body_quat_relative_w=command.body_quat_relative_w.clone(),
+      joint_vel=command.joint_vel.clone(),
+    )
+
+    with torch.no_grad():
+      actions = policy(obs)
+    obs, _, dones, _ = env.step(actions)
+
+    # Pair the snapshotted reference with the post-step robot state.
+    ref.robot_body_pos_w = command.robot_body_pos_w
+    ref.robot_body_quat_w = command.robot_body_quat_w
+    ref.robot_joint_vel = command.robot_joint_vel
+    ref_command = cast(MotionCommand, ref)
+
+    # Accumulate metrics for envs still running this step. active.any() is
+    # always true here: the loop runs only while some env is not done, and
+    # done_envs is updated below after this point.
+    active = ~done_envs
+    all_active.append(active.float())
+    all_mpkpe.append(torch.where(active, compute_mpkpe(ref_command), 0.0))
+    all_r_mpkpe.append(
+      torch.where(active, compute_root_relative_mpkpe(ref_command), 0.0)
+    )
+    all_joint_vel_error.append(
+      torch.where(active, compute_joint_velocity_error(ref_command), 0.0)
+    )
+    all_ee_pos_error.append(
+      torch.where(active, compute_ee_position_error(ref_command, ee_body_names), 0.0)
+    )
+    all_ee_ori_error.append(
+      torch.where(active, compute_ee_orientation_error(ref_command, ee_body_names), 0.0)
+    )
+
+    # Track completions.
+    terminated = env.unwrapped.termination_manager.terminated
+    truncated = env.unwrapped.termination_manager.time_outs
+    newly_done = dones.bool() & ~done_envs
+
+    if newly_done.any():
+      success = success | (newly_done & truncated & ~terminated)
+      done_envs = done_envs | newly_done
+      print(
+        f"[INFO] {done_envs.sum().item()}/{cfg.num_envs} episodes completed "
+        f"(step {step}, truncated={(newly_done & truncated).sum().item()}, "
+        f"terminated={(newly_done & terminated).sum().item()})"
+      )
+    step += 1
+
+  # Compute mean metrics over the steps each env was active.
+  stacks = [
+    all_mpkpe,
+    all_r_mpkpe,
+    all_joint_vel_error,
+    all_ee_pos_error,
+    all_ee_ori_error,
+  ]
+  stacks = [torch.stack(s, dim=0) for s in stacks]
+  active_steps = torch.stack(all_active, dim=0).sum(dim=0).clamp(min=1)
+  means = [s.sum(dim=0) / active_steps for s in stacks]
+
+  metrics = {
+    "success_rate": success.float().mean().item(),
+    "mpkpe": means[0].mean().item(),
+    "r_mpkpe": means[1].mean().item(),
+    "joint_vel_error": means[2].mean().item(),
+    "ee_pos_error": means[3].mean().item(),
+    "ee_ori_error": means[4].mean().item(),
+  }
+
+  print("\n" + "=" * 50)
+  print("Evaluation Results")
+  print("=" * 50)
+  for name, value in metrics.items():
+    print(f"  {name}: {value:.4f}")
+  print("=" * 50)
+
+  if cfg.output_file:
+    output_path = Path(cfg.output_file)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(output_path, "w") as f:
+      json.dump(metrics, f, indent=2)
+    print(f"[INFO] Metrics saved to {output_path}")
+
+  env.close()
+  return metrics
+
+
+def main():
+  import mjlab.tasks  # noqa: F401
+
+  tracking_tasks = [t for t in list_tasks() if "Tracking" in t]
+  if not tracking_tasks:
+    print("No tracking tasks found.")
+    sys.exit(1)
+
+  chosen_task, remaining_args = tyro.cli(
+    tyro.extras.literal_type_from_choices(tracking_tasks),
+    add_help=False,
+    return_unknown_args=True,
+    config=mjlab.TYRO_FLAGS,
+  )
+
+  args = tyro.cli(
+    EvaluateConfig,
+    args=remaining_args,
+    prog=sys.argv[0] + f" {chosen_task}",
+    config=mjlab.TYRO_FLAGS,
+  )
+
+  run_evaluate(chosen_task, args)
+
+
+if __name__ == "__main__":
+  main()
diff --git a/src/mjlab/tasks/tracking/tracking_env_cfg.py b/src/mjlab/tasks/tracking/tracking_env_cfg.py
new file mode 100644
index 0000000..53275ef
--- /dev/null
+++ b/src/mjlab/tasks/tracking/tracking_env_cfg.py
@@ -0,0 +1,313 @@
+"""Motion mimic task configuration.
+
+This module defines the base configuration for motion mimic tasks.
+Robot-specific configurations are located in the config/ directory.
+
+This is a re-implementation of BeyondMimic (https://beyondmimic.github.io/).
+
+Based on https://github.com/HybridRobotics/whole_body_tracking
+Commit: f8e20c880d9c8ec7172a13d3a88a65e3a5a88448
+"""
+
+from mjlab.envs import ManagerBasedRlEnvCfg
+from mjlab.envs.mdp import dr
+from mjlab.envs.mdp.actions import JointPositionActionCfg
+from mjlab.managers.action_manager import ActionTermCfg
+from mjlab.managers.command_manager import CommandTermCfg
+from mjlab.managers.event_manager import EventTermCfg
+from mjlab.managers.observation_manager import ObservationGroupCfg, ObservationTermCfg
+from mjlab.managers.reward_manager import RewardTermCfg
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.managers.termination_manager import TerminationTermCfg
+from mjlab.scene import SceneCfg
+from mjlab.sim import MujocoCfg, SimulationCfg
+from mjlab.tasks.tracking import mdp
+from mjlab.tasks.tracking.mdp import MotionCommandCfg
+from mjlab.terrains import TerrainEntityCfg
+from mjlab.utils.noise import UniformNoiseCfg as Unoise
+from mjlab.viewer import ViewerConfig
+
+VELOCITY_RANGE = {
+  "x": (-0.5, 0.5),
+  "y": (-0.5, 0.5),
+  "z": (-0.2, 0.2),
+  "roll": (-0.52, 0.52),
+  "pitch": (-0.52, 0.52),
+  "yaw": (-0.78, 0.78),
+}
+
+
+def make_tracking_env_cfg() -> ManagerBasedRlEnvCfg:
+  """Create base tracking task configuration."""
+
+  ##
+  # Observations
+  ##
+
+  actor_terms = {
+    "command": ObservationTermCfg(
+      func=mdp.generated_commands, params={"command_name": "motion"}
+    ),
+    "motion_anchor_pos_b": ObservationTermCfg(
+      func=mdp.motion_anchor_pos_b,
+      params={"command_name": "motion"},
+      noise=Unoise(n_min=-0.25, n_max=0.25),
+    ),
+    "motion_anchor_ori_b": ObservationTermCfg(
+      func=mdp.motion_anchor_ori_b,
+      params={"command_name": "motion"},
+      noise=Unoise(n_min=-0.05, n_max=0.05),
+    ),
+    "base_lin_vel": ObservationTermCfg(
+      func=mdp.builtin_sensor,
+      params={"sensor_name": "robot/imu_lin_vel"},
+      noise=Unoise(n_min=-0.5, n_max=0.5),
+    ),
+    "base_ang_vel": ObservationTermCfg(
+      func=mdp.builtin_sensor,
+      params={"sensor_name": "robot/imu_ang_vel"},
+      noise=Unoise(n_min=-0.2, n_max=0.2),
+    ),
+    "joint_pos": ObservationTermCfg(
+      func=mdp.joint_pos_rel,
+      noise=Unoise(n_min=-0.01, n_max=0.01),
+      params={"biased": True},
+    ),
+    "joint_vel": ObservationTermCfg(
+      func=mdp.joint_vel_rel, noise=Unoise(n_min=-0.5, n_max=0.5)
+    ),
+    "actions": ObservationTermCfg(func=mdp.last_action),
+  }
+
+  critic_terms = {
+    "command": ObservationTermCfg(
+      func=mdp.generated_commands, params={"command_name": "motion"}
+    ),
+    "motion_anchor_pos_b": ObservationTermCfg(
+      func=mdp.motion_anchor_pos_b, params={"command_name": "motion"}
+    ),
+    "motion_anchor_ori_b": ObservationTermCfg(
+      func=mdp.motion_anchor_ori_b, params={"command_name": "motion"}
+    ),
+    "body_pos": ObservationTermCfg(
+      func=mdp.robot_body_pos_b, params={"command_name": "motion"}
+    ),
+    "body_ori": ObservationTermCfg(
+      func=mdp.robot_body_ori_b, params={"command_name": "motion"}
+    ),
+    "base_lin_vel": ObservationTermCfg(
+      func=mdp.builtin_sensor, params={"sensor_name": "robot/imu_lin_vel"}
+    ),
+    "base_ang_vel": ObservationTermCfg(
+      func=mdp.builtin_sensor, params={"sensor_name": "robot/imu_ang_vel"}
+    ),
+    "joint_pos": ObservationTermCfg(func=mdp.joint_pos_rel),
+    "joint_vel": ObservationTermCfg(func=mdp.joint_vel_rel),
+    "actions": ObservationTermCfg(func=mdp.last_action),
+  }
+
+  observations = {
+    "actor": ObservationGroupCfg(
+      terms=actor_terms,
+      concatenate_terms=True,
+      enable_corruption=True,
+    ),
+    "critic": ObservationGroupCfg(
+      terms=critic_terms,
+      concatenate_terms=True,
+      enable_corruption=False,
+    ),
+  }
+
+  ##
+  # Actions
+  ##
+
+  actions: dict[str, ActionTermCfg] = {
+    "joint_pos": JointPositionActionCfg(
+      entity_name="robot",
+      actuator_names=(".*",),
+      scale=0.5,
+      use_default_offset=True,
+    )
+  }
+
+  ##
+  # Commands
+  ##
+
+  commands: dict[str, CommandTermCfg] = {
+    "motion": MotionCommandCfg(
+      entity_name="robot",
+      resampling_time_range=(1.0e9, 1.0e9),
+      debug_vis=True,
+      pose_range={
+        "x": (-0.05, 0.05),
+        "y": (-0.05, 0.05),
+        "z": (-0.01, 0.01),
+        "roll": (-0.1, 0.1),
+        "pitch": (-0.1, 0.1),
+        "yaw": (-0.2, 0.2),
+      },
+      velocity_range=VELOCITY_RANGE,
+      joint_position_range=(-0.1, 0.1),
+      # Override in robot cfg.
+      motion_file="",
+      anchor_body_name="",
+      body_names=(),
+    )
+  }
+
+  ##
+  # Events
+  ##
+
+  events: dict[str, EventTermCfg] = {
+    "push_robot": EventTermCfg(
+      func=mdp.push_by_setting_velocity,
+      mode="interval",
+      interval_range_s=(1.0, 3.0),
+      params={"velocity_range": VELOCITY_RANGE},
+    ),
+    "base_com": EventTermCfg(
+      mode="startup",
+      func=dr.body_com_offset,
+      params={
+        "asset_cfg": SceneEntityCfg("robot", body_names=()),  # Set in robot cfg.
+        "operation": "add",
+        "ranges": {
+          0: (-0.025, 0.025),
+          1: (-0.05, 0.05),
+          2: (-0.05, 0.05),
+        },
+      },
+    ),
+    "encoder_bias": EventTermCfg(
+      mode="startup",
+      func=dr.encoder_bias,
+      params={
+        "asset_cfg": SceneEntityCfg("robot"),
+        "bias_range": (-0.01, 0.01),
+      },
+    ),
+    "foot_friction": EventTermCfg(
+      mode="startup",
+      func=dr.geom_friction,
+      params={
+        "asset_cfg": SceneEntityCfg("robot", geom_names=()),  # Set per-robot.
+        "operation": "abs",
+        "ranges": (0.3, 1.2),
+        "shared_random": True,  # All foot geoms share the same friction.
+      },
+    ),
+  }
+
+  ##
+  # Rewards
+  ##
+
+  rewards: dict[str, RewardTermCfg] = {
+    "motion_global_root_pos": RewardTermCfg(
+      func=mdp.motion_global_anchor_position_error_exp,
+      weight=0.5,
+      params={"command_name": "motion", "std": 0.3},
+    ),
+    "motion_global_root_ori": RewardTermCfg(
+      func=mdp.motion_global_anchor_orientation_error_exp,
+      weight=0.5,
+      params={"command_name": "motion", "std": 0.4},
+    ),
+    "motion_body_pos": RewardTermCfg(
+      func=mdp.motion_relative_body_position_error_exp,
+      weight=1.0,
+      params={"command_name": "motion", "std": 0.3},
+    ),
+    "motion_body_ori": RewardTermCfg(
+      func=mdp.motion_relative_body_orientation_error_exp,
+      weight=1.0,
+      params={"command_name": "motion", "std": 0.4},
+    ),
+    "motion_body_lin_vel": RewardTermCfg(
+      func=mdp.motion_global_body_linear_velocity_error_exp,
+      weight=1.0,
+      params={"command_name": "motion", "std": 1.0},
+    ),
+    "motion_body_ang_vel": RewardTermCfg(
+      func=mdp.motion_global_body_angular_velocity_error_exp,
+      weight=1.0,
+      params={"command_name": "motion", "std": 3.14},
+    ),
+    "action_rate_l2": RewardTermCfg(func=mdp.action_rate_l2, weight=-1e-1),
+    "joint_limit": RewardTermCfg(
+      func=mdp.joint_pos_limits,
+      weight=-10.0,
+      params={"asset_cfg": SceneEntityCfg("robot", joint_names=(".*",))},
+    ),
+    "self_collisions": RewardTermCfg(
+      func=mdp.self_collision_cost,
+      weight=-10.0,
+      params={"sensor_name": "self_collision", "force_threshold": 10.0},
+    ),
+  }
+
+  ##
+  # Terminations
+  ##
+
+  terminations: dict[str, TerminationTermCfg] = {
+    "time_out": TerminationTermCfg(func=mdp.time_out, time_out=True),
+    "anchor_pos": TerminationTermCfg(
+      func=mdp.bad_anchor_pos_z_only,
+      params={"command_name": "motion", "threshold": 0.25},
+    ),
+    "anchor_ori": TerminationTermCfg(
+      func=mdp.bad_anchor_ori,
+      params={
+        "asset_cfg": SceneEntityCfg("robot"),
+        "command_name": "motion",
+        "threshold": 0.8,
+      },
+    ),
+    "ee_body_pos": TerminationTermCfg(
+      func=mdp.bad_motion_body_pos_z_only,
+      params={
+        "command_name": "motion",
+        "threshold": 0.25,
+        "body_names": (),  # Set per-robot.
+      },
+    ),
+  }
+
+  ##
+  # Assemble and return
+  ##
+
+  return ManagerBasedRlEnvCfg(
+    scene=SceneCfg(terrain=TerrainEntityCfg(terrain_type="plane"), num_envs=1),
+    observations=observations,
+    actions=actions,
+    commands=commands,
+    events=events,
+    rewards=rewards,
+    terminations=terminations,
+    viewer=ViewerConfig(
+      origin_type=ViewerConfig.OriginType.ASSET_BODY,
+      entity_name="robot",
+      body_name="",  # Set per-robot.
+      distance=2.8,
+      fovy=55.0,
+      elevation=-5.0,
+      azimuth=120.0,
+    ),
+    sim=SimulationCfg(
+      nconmax=35,
+      njmax=250,
+      mujoco=MujocoCfg(
+        timestep=0.005,
+        iterations=10,
+        ls_iterations=20,
+      ),
+    ),
+    decimation=4,
+    episode_length_s=10.0,
+  )
diff --git a/src/mjlab/tasks/velocity/__init__.py b/src/mjlab/tasks/velocity/__init__.py
new file mode 100644
index 0000000..1a794e4
--- /dev/null
+++ b/src/mjlab/tasks/velocity/__init__.py
@@ -0,0 +1 @@
+"""Velocity tracking environments for legged robots."""
diff --git a/src/mjlab/tasks/velocity/config/__init__.py b/src/mjlab/tasks/velocity/config/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/mjlab/tasks/velocity/config/g1/__init__.py b/src/mjlab/tasks/velocity/config/g1/__init__.py
new file mode 100644
index 0000000..debab01
--- /dev/null
+++ b/src/mjlab/tasks/velocity/config/g1/__init__.py
@@ -0,0 +1,24 @@
+from mjlab.tasks.registry import register_mjlab_task
+from mjlab.tasks.velocity.rl import VelocityOnPolicyRunner
+
+from .env_cfgs import (
+  unitree_g1_flat_env_cfg,
+  unitree_g1_rough_env_cfg,
+)
+from .rl_cfg import unitree_g1_ppo_runner_cfg
+
+register_mjlab_task(
+  task_id="Mjlab-Velocity-Rough-Unitree-G1",
+  env_cfg=unitree_g1_rough_env_cfg(),
+  play_env_cfg=unitree_g1_rough_env_cfg(play=True),
+  rl_cfg=unitree_g1_ppo_runner_cfg(),
+  runner_cls=VelocityOnPolicyRunner,
+)
+
+register_mjlab_task(
+  task_id="Mjlab-Velocity-Flat-Unitree-G1",
+  env_cfg=unitree_g1_flat_env_cfg(),
+  play_env_cfg=unitree_g1_flat_env_cfg(play=True),
+  rl_cfg=unitree_g1_ppo_runner_cfg(),
+  runner_cls=VelocityOnPolicyRunner,
+)
diff --git a/src/mjlab/tasks/velocity/config/g1/env_cfgs.py b/src/mjlab/tasks/velocity/config/g1/env_cfgs.py
new file mode 100644
index 0000000..28bb3f4
--- /dev/null
+++ b/src/mjlab/tasks/velocity/config/g1/env_cfgs.py
@@ -0,0 +1,220 @@
+"""Unitree G1 velocity environment configurations."""
+
+from mjlab.asset_zoo.robots import (
+  G1_ACTION_SCALE,
+  get_g1_robot_cfg,
+)
+from mjlab.envs import ManagerBasedRlEnvCfg
+from mjlab.envs import mdp as envs_mdp
+from mjlab.envs.mdp.actions import JointPositionActionCfg
+from mjlab.managers.event_manager import EventTermCfg
+from mjlab.managers.reward_manager import RewardTermCfg
+from mjlab.sensor import (
+  ContactMatch,
+  ContactSensorCfg,
+  ObjRef,
+  RayCastSensorCfg,
+  RingPatternCfg,
+  TerrainHeightSensorCfg,
+)
+from mjlab.tasks.velocity import mdp
+from mjlab.tasks.velocity.mdp import UniformVelocityCommandCfg
+from mjlab.tasks.velocity.velocity_env_cfg import make_velocity_env_cfg
+
+
+def unitree_g1_rough_env_cfg(play: bool = False) -> ManagerBasedRlEnvCfg:
+  """Create Unitree G1 rough terrain velocity configuration."""
+  cfg = make_velocity_env_cfg()
+
+  cfg.sim.mujoco.ccd_iterations = 500
+  cfg.sim.contact_sensor_maxmatch = 500
+  cfg.sim.nconmax = 70
+
+  cfg.scene.entities = {"robot": get_g1_robot_cfg()}
+
+  # Set raycast sensor frame to G1 pelvis.
+  for sensor in cfg.scene.sensors or ():
+    if sensor.name == "terrain_scan":
+      assert isinstance(sensor, RayCastSensorCfg)
+      assert isinstance(sensor.frame, ObjRef)
+      sensor.frame.name = "pelvis"
+
+  site_names = ("left_foot", "right_foot")
+  geom_names = tuple(
+    f"{side}_foot{i}_collision" for side in ("left", "right") for i in range(1, 8)
+  )
+
+  # Wire foot height scan to per-foot sites.
+  for sensor in cfg.scene.sensors or ():
+    if sensor.name == "foot_height_scan":
+      assert isinstance(sensor, TerrainHeightSensorCfg)
+      sensor.frame = tuple(
+        ObjRef(type="site", name=s, entity="robot") for s in site_names
+      )
+      sensor.pattern = RingPatternCfg.single_ring(radius=0.03, num_samples=6)
+
+  feet_ground_cfg = ContactSensorCfg(
+    name="feet_ground_contact",
+    primary=ContactMatch(
+      mode="subtree",
+      pattern=r"^(left_ankle_roll_link|right_ankle_roll_link)$",
+      entity="robot",
+    ),
+    secondary=ContactMatch(mode="body", pattern="terrain"),
+    fields=("found", "force"),
+    reduce="netforce",
+    num_slots=1,
+    track_air_time=True,
+  )
+  self_collision_cfg = ContactSensorCfg(
+    name="self_collision",
+    primary=ContactMatch(mode="subtree", pattern="pelvis", entity="robot"),
+    secondary=ContactMatch(mode="subtree", pattern="pelvis", entity="robot"),
+    fields=("found", "force"),
+    reduce="none",
+    num_slots=1,
+    history_length=4,
+  )
+  cfg.scene.sensors = (cfg.scene.sensors or ()) + (
+    feet_ground_cfg,
+    self_collision_cfg,
+  )
+
+  if cfg.scene.terrain is not None and cfg.scene.terrain.terrain_generator is not None:
+    cfg.scene.terrain.terrain_generator.curriculum = True
+
+  joint_pos_action = cfg.actions["joint_pos"]
+  assert isinstance(joint_pos_action, JointPositionActionCfg)
+  joint_pos_action.scale = G1_ACTION_SCALE
+
+  cfg.viewer.body_name = "torso_link"
+
+  twist_cmd = cfg.commands["twist"]
+  assert isinstance(twist_cmd, UniformVelocityCommandCfg)
+  twist_cmd.viz.z_offset = 1.15
+
+  cfg.events["foot_friction"].params["asset_cfg"].geom_names = geom_names
+  cfg.events["base_com"].params["asset_cfg"].body_names = ("torso_link",)
+
+  # Rationale for std values:
+  # - Knees/hip_pitch get the loosest std to allow natural leg bending during stride.
+  # - Hip roll/yaw stay tighter to prevent excessive lateral sway and keep gait stable.
+  # - Ankle roll is very tight for balance; ankle pitch looser for foot clearance.
+  # - Waist roll/pitch stay tight to keep the torso upright and stable.
+  # - Shoulders/elbows get moderate freedom for natural arm swing during walking.
+  # - Wrists are loose (0.3) since they don't affect balance much.
+  # Running values are ~1.5-2x walking values to accommodate larger motion range.
+  cfg.rewards["pose"].params["std_standing"] = {".*": 0.05}
+  cfg.rewards["pose"].params["std_walking"] = {
+    # Lower body.
+    r".*hip_pitch.*": 0.3,
+    r".*hip_roll.*": 0.15,
+    r".*hip_yaw.*": 0.15,
+    r".*knee.*": 0.35,
+    r".*ankle_pitch.*": 0.25,
+    r".*ankle_roll.*": 0.1,
+    # Waist.
+    r".*waist_yaw.*": 0.2,
+    r".*waist_roll.*": 0.08,
+    r".*waist_pitch.*": 0.1,
+    # Arms.
+    r".*shoulder_pitch.*": 0.15,
+    r".*shoulder_roll.*": 0.15,
+    r".*shoulder_yaw.*": 0.1,
+    r".*elbow.*": 0.15,
+    r".*wrist.*": 0.3,
+  }
+  cfg.rewards["pose"].params["std_running"] = {
+    # Lower body.
+    r".*hip_pitch.*": 0.5,
+    r".*hip_roll.*": 0.2,
+    r".*hip_yaw.*": 0.2,
+    r".*knee.*": 0.6,
+    r".*ankle_pitch.*": 0.35,
+    r".*ankle_roll.*": 0.15,
+    # Waist.
+    r".*waist_yaw.*": 0.3,
+    r".*waist_roll.*": 0.08,
+    r".*waist_pitch.*": 0.2,
+    # Arms.
+    r".*shoulder_pitch.*": 0.5,
+    r".*shoulder_roll.*": 0.2,
+    r".*shoulder_yaw.*": 0.15,
+    r".*elbow.*": 0.35,
+    r".*wrist.*": 0.3,
+  }
+
+  cfg.rewards["upright"].params["asset_cfg"].body_names = ("torso_link",)
+  cfg.rewards["body_ang_vel"].params["asset_cfg"].body_names = ("torso_link",)
+
+  for reward_name in ["foot_clearance", "foot_slip"]:
+    cfg.rewards[reward_name].params["asset_cfg"].site_names = site_names
+
+  cfg.rewards["body_ang_vel"].weight = -0.05
+  cfg.rewards["angular_momentum"].weight = -0.02
+  cfg.rewards["air_time"].weight = 0.0
+
+  cfg.rewards["self_collisions"] = RewardTermCfg(
+    func=mdp.self_collision_cost,
+    weight=-1.0,
+    params={"sensor_name": self_collision_cfg.name, "force_threshold": 10.0},
+  )
+
+  # Apply play mode overrides.
+  if play:
+    # Effectively infinite episode length.
+    cfg.episode_length_s = int(1e9)
+
+    cfg.observations["actor"].enable_corruption = False
+    cfg.events.pop("push_robot", None)
+    cfg.terminations.pop("out_of_terrain_bounds", None)
+    cfg.curriculum = {}
+    cfg.events["randomize_terrain"] = EventTermCfg(
+      func=envs_mdp.randomize_terrain,
+      mode="reset",
+      params={},
+    )
+
+    if cfg.scene.terrain is not None:
+      if cfg.scene.terrain.terrain_generator is not None:
+        cfg.scene.terrain.terrain_generator.curriculum = False
+        cfg.scene.terrain.terrain_generator.num_cols = 5
+        cfg.scene.terrain.terrain_generator.num_rows = 5
+        cfg.scene.terrain.terrain_generator.border_width = 10.0
+
+  return cfg
+
+
+def unitree_g1_flat_env_cfg(play: bool = False) -> ManagerBasedRlEnvCfg:
+  """Create Unitree G1 flat terrain velocity configuration."""
+  cfg = unitree_g1_rough_env_cfg(play=play)
+
+  cfg.sim.njmax = 300
+  cfg.sim.mujoco.ccd_iterations = 50
+  cfg.sim.contact_sensor_maxmatch = 64
+  cfg.sim.nconmax = None
+
+  # Switch to flat terrain.
+  assert cfg.scene.terrain is not None
+  cfg.scene.terrain.terrain_type = "plane"
+  cfg.scene.terrain.terrain_generator = None
+
+  # Remove raycast sensor and height scan (no terrain to scan).
+  cfg.scene.sensors = tuple(
+    s for s in (cfg.scene.sensors or ()) if s.name != "terrain_scan"
+  )
+  del cfg.observations["actor"].terms["height_scan"]
+  del cfg.observations["critic"].terms["height_scan"]
+
+  cfg.terminations.pop("out_of_terrain_bounds", None)
+
+  # Disable terrain curriculum (not present in play mode since rough clears all).
+  cfg.curriculum.pop("terrain_levels", None)
+
+  if play:
+    twist_cmd = cfg.commands["twist"]
+    assert isinstance(twist_cmd, UniformVelocityCommandCfg)
+    twist_cmd.ranges.lin_vel_x = (-1.5, 2.0)
+    twist_cmd.ranges.ang_vel_z = (-0.7, 0.7)
+
+  return cfg
diff --git a/src/mjlab/tasks/velocity/config/g1/rl_cfg.py b/src/mjlab/tasks/velocity/config/g1/rl_cfg.py
new file mode 100644
index 0000000..c2475f2
--- /dev/null
+++ b/src/mjlab/tasks/velocity/config/g1/rl_cfg.py
@@ -0,0 +1,46 @@
+"""RL configuration for Unitree G1 velocity task."""
+
+from mjlab.rl import (
+  RslRlModelCfg,
+  RslRlOnPolicyRunnerCfg,
+  RslRlPpoAlgorithmCfg,
+)
+
+
+def unitree_g1_ppo_runner_cfg() -> RslRlOnPolicyRunnerCfg:
+  """Create RL runner configuration for Unitree G1 velocity task."""
+  return RslRlOnPolicyRunnerCfg(
+    actor=RslRlModelCfg(
+      hidden_dims=(512, 256, 128),
+      activation="elu",
+      obs_normalization=True,
+      distribution_cfg={
+        "class_name": "GaussianDistribution",
+        "init_std": 1.0,
+        "std_type": "scalar",
+      },
+    ),
+    critic=RslRlModelCfg(
+      hidden_dims=(512, 256, 128),
+      activation="elu",
+      obs_normalization=True,
+    ),
+    algorithm=RslRlPpoAlgorithmCfg(
+      value_loss_coef=1.0,
+      use_clipped_value_loss=True,
+      clip_param=0.2,
+      entropy_coef=0.01,
+      num_learning_epochs=5,
+      num_mini_batches=4,
+      learning_rate=1.0e-3,
+      schedule="adaptive",
+      gamma=0.99,
+      lam=0.95,
+      desired_kl=0.01,
+      max_grad_norm=1.0,
+    ),
+    experiment_name="g1_velocity",
+    save_interval=50,
+    num_steps_per_env=24,
+    max_iterations=30_000,
+  )
diff --git a/src/mjlab/tasks/velocity/config/go1/__init__.py b/src/mjlab/tasks/velocity/config/go1/__init__.py
new file mode 100644
index 0000000..259c0ba
--- /dev/null
+++ b/src/mjlab/tasks/velocity/config/go1/__init__.py
@@ -0,0 +1,24 @@
+from mjlab.tasks.registry import register_mjlab_task
+from mjlab.tasks.velocity.rl import VelocityOnPolicyRunner
+
+from .env_cfgs import (
+  unitree_go1_flat_env_cfg,
+  unitree_go1_rough_env_cfg,
+)
+from .rl_cfg import unitree_go1_ppo_runner_cfg
+
+register_mjlab_task(
+  task_id="Mjlab-Velocity-Rough-Unitree-Go1",
+  env_cfg=unitree_go1_rough_env_cfg(),
+  play_env_cfg=unitree_go1_rough_env_cfg(play=True),
+  rl_cfg=unitree_go1_ppo_runner_cfg(),
+  runner_cls=VelocityOnPolicyRunner,
+)
+
+register_mjlab_task(
+  task_id="Mjlab-Velocity-Flat-Unitree-Go1",
+  env_cfg=unitree_go1_flat_env_cfg(),
+  play_env_cfg=unitree_go1_flat_env_cfg(play=True),
+  rl_cfg=unitree_go1_ppo_runner_cfg(),
+  runner_cls=VelocityOnPolicyRunner,
+)
diff --git a/src/mjlab/tasks/velocity/config/go1/env_cfgs.py b/src/mjlab/tasks/velocity/config/go1/env_cfgs.py
new file mode 100644
index 0000000..918c0a1
--- /dev/null
+++ b/src/mjlab/tasks/velocity/config/go1/env_cfgs.py
@@ -0,0 +1,311 @@
+"""Unitree Go1 velocity environment configurations."""
+
+import math
+from typing import Literal
+
+from mjlab.asset_zoo.robots import (
+  GO1_ACTION_SCALE,
+  get_go1_robot_cfg,
+)
+from mjlab.envs import ManagerBasedRlEnvCfg
+from mjlab.envs import mdp as envs_mdp
+from mjlab.envs.mdp.actions import JointPositionActionCfg
+from mjlab.managers import TerminationTermCfg
+from mjlab.managers.event_manager import EventTermCfg
+from mjlab.managers.reward_manager import RewardTermCfg
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.sensor import (
+  ContactMatch,
+  ContactSensorCfg,
+  ObjRef,
+  RayCastSensorCfg,
+  RingPatternCfg,
+  TerrainHeightSensorCfg,
+)
+from mjlab.tasks.velocity import mdp
+from mjlab.tasks.velocity.mdp import UniformVelocityCommandCfg
+from mjlab.tasks.velocity.velocity_env_cfg import make_velocity_env_cfg
+
+TerrainType = Literal["rough", "obstacles"]
+
+
+def unitree_go1_rough_env_cfg(
+  play: bool = False,
+) -> ManagerBasedRlEnvCfg:
+  """Create Unitree Go1 rough terrain velocity configuration."""
+  cfg = make_velocity_env_cfg()
+
+  cfg.sim.mujoco.ccd_iterations = 500
+  cfg.sim.mujoco.impratio = 10
+  cfg.sim.mujoco.cone = "elliptic"
+  cfg.sim.contact_sensor_maxmatch = 500
+
+  cfg.scene.entities = {"robot": get_go1_robot_cfg()}
+
+  # Set raycast sensor frame to Go1 trunk.
+  for sensor in cfg.scene.sensors or ():
+    if sensor.name == "terrain_scan":
+      assert isinstance(sensor, RayCastSensorCfg)
+      assert isinstance(sensor.frame, ObjRef)
+      sensor.frame.name = "trunk"
+
+  foot_names = ("FR", "FL", "RR", "RL")
+  site_names = ("FR", "FL", "RR", "RL")
+  geom_names = tuple(f"{name}_foot_collision" for name in foot_names)
+
+  # Wire foot height scan to per-foot sites.
+  for sensor in cfg.scene.sensors or ():
+    if sensor.name == "foot_height_scan":
+      assert isinstance(sensor, TerrainHeightSensorCfg)
+      sensor.frame = tuple(
+        ObjRef(type="site", name=s, entity="robot") for s in site_names
+      )
+      sensor.pattern = RingPatternCfg.single_ring(radius=0.04, num_samples=4)
+
+  feet_ground_cfg = ContactSensorCfg(
+    name="feet_ground_contact",
+    primary=ContactMatch(mode="geom", pattern=geom_names, entity="robot"),
+    secondary=ContactMatch(mode="body", pattern="terrain"),
+    fields=("found", "force"),
+    reduce="netforce",
+    num_slots=1,
+    track_air_time=True,
+  )
+  self_collision_cfg = ContactSensorCfg(
+    name="self_collision",
+    primary=ContactMatch(mode="subtree", pattern="trunk", entity="robot"),
+    secondary=ContactMatch(mode="subtree", pattern="trunk", entity="robot"),
+    fields=("found", "force"),
+    reduce="none",
+    num_slots=1,
+    history_length=4,
+  )
+  thigh_geom_names = tuple(
+    f"{leg}_thigh_collision{i}" for leg in foot_names for i in (1, 2, 3)
+  )
+  thigh_ground_cfg = ContactSensorCfg(
+    name="thigh_ground_touch",
+    primary=ContactMatch(
+      mode="geom",
+      entity="robot",
+      pattern=thigh_geom_names,
+    ),
+    secondary=ContactMatch(mode="body", pattern="terrain"),
+    fields=("found", "force"),
+    reduce="none",
+    num_slots=1,
+    history_length=4,
+  )
+  calf_geom_names = tuple(
+    f"{leg}_calf_collision{i}" for leg in foot_names for i in (1, 2)
+  )
+  shank_ground_cfg = ContactSensorCfg(
+    name="shank_ground_touch",
+    primary=ContactMatch(
+      mode="geom",
+      entity="robot",
+      pattern=calf_geom_names,
+    ),
+    secondary=ContactMatch(mode="body", pattern="terrain"),
+    fields=("found", "force"),
+    reduce="none",
+    num_slots=1,
+    history_length=4,
+  )
+  trunk_head_ground_cfg = ContactSensorCfg(
+    name="trunk_ground_touch",
+    primary=ContactMatch(
+      mode="geom",
+      entity="robot",
+      pattern=("trunk_collision", "head_collision"),
+    ),
+    secondary=ContactMatch(mode="body", pattern="terrain"),
+    fields=("found", "force"),
+    reduce="none",
+    num_slots=1,
+    history_length=4,
+  )
+  cfg.scene.sensors = (cfg.scene.sensors or ()) + (
+    feet_ground_cfg,
+    self_collision_cfg,
+    thigh_ground_cfg,
+    shank_ground_cfg,
+    trunk_head_ground_cfg,
+  )
+
+  if cfg.scene.terrain is not None and cfg.scene.terrain.terrain_generator is not None:
+    cfg.scene.terrain.terrain_generator.curriculum = True
+
+  joint_pos_action = cfg.actions["joint_pos"]
+  assert isinstance(joint_pos_action, JointPositionActionCfg)
+  joint_pos_action.scale = GO1_ACTION_SCALE
+
+  cfg.viewer.body_name = "trunk"
+  cfg.viewer.distance = 1.5
+  cfg.viewer.elevation = -10.0
+
+  # Replace the base foot_friction with per-axis friction events for condim 6.
+  del cfg.events["foot_friction"]
+  cfg.events["foot_friction_slide"] = EventTermCfg(
+    mode="startup",
+    func=envs_mdp.dr.geom_friction,
+    params={
+      "asset_cfg": SceneEntityCfg("robot", geom_names=geom_names),
+      "operation": "abs",
+      "axes": [0],
+      "ranges": (0.3, 1.5),
+      "shared_random": True,
+    },
+  )
+  cfg.events["foot_friction_spin"] = EventTermCfg(
+    mode="startup",
+    func=envs_mdp.dr.geom_friction,
+    params={
+      "asset_cfg": SceneEntityCfg("robot", geom_names=geom_names),
+      "operation": "abs",
+      "distribution": "log_uniform",
+      "axes": [1],
+      "ranges": (1e-4, 2e-2),
+      "shared_random": True,
+    },
+  )
+  cfg.events["foot_friction_roll"] = EventTermCfg(
+    mode="startup",
+    func=envs_mdp.dr.geom_friction,
+    params={
+      "asset_cfg": SceneEntityCfg("robot", geom_names=geom_names),
+      "operation": "abs",
+      "distribution": "log_uniform",
+      "axes": [2],
+      "ranges": (1e-5, 5e-3),
+      "shared_random": True,
+    },
+  )
+  cfg.events["base_com"].params["asset_cfg"].body_names = ("trunk",)
+
+  cfg.rewards["pose"].params["std_standing"] = {
+    r".*(FR|FL|RR|RL)_(hip|thigh)_joint.*": 0.05,
+    r".*(FR|FL|RR|RL)_calf_joint.*": 0.1,
+  }
+  cfg.rewards["pose"].params["std_walking"] = {
+    r".*(FR|FL|RR|RL)_(hip|thigh)_joint.*": 0.3,
+    r".*(FR|FL|RR|RL)_calf_joint.*": 0.6,
+  }
+  cfg.rewards["pose"].params["std_running"] = {
+    r".*(FR|FL|RR|RL)_(hip|thigh)_joint.*": 0.3,
+    r".*(FR|FL|RR|RL)_calf_joint.*": 0.6,
+  }
+
+  cfg.rewards["upright"].params["asset_cfg"].body_names = ("trunk",)
+  cfg.rewards["upright"].params["terrain_sensor_names"] = ("terrain_scan",)
+  cfg.rewards["body_ang_vel"].params["asset_cfg"].body_names = ("trunk",)
+
+  for reward_name in ["foot_clearance", "foot_slip"]:
+    cfg.rewards[reward_name].params["asset_cfg"].site_names = site_names
+
+  cfg.rewards["body_ang_vel"].weight = 0.0
+  cfg.rewards["angular_momentum"].weight = 0.0
+  cfg.rewards["air_time"].weight = 0.0
+
+  # Per-body-group collision penalties.
+  cfg.rewards["self_collisions"] = RewardTermCfg(
+    func=mdp.self_collision_cost,
+    weight=-0.1,
+    params={"sensor_name": self_collision_cfg.name},
+  )
+  cfg.rewards["shank_collision"] = RewardTermCfg(
+    func=mdp.self_collision_cost,
+    weight=-0.1,
+    params={"sensor_name": shank_ground_cfg.name},
+  )
+  cfg.rewards["trunk_head_collision"] = RewardTermCfg(
+    func=mdp.self_collision_cost,
+    weight=-0.1,
+    params={"sensor_name": trunk_head_ground_cfg.name},
+  )
+
+  # On rough terrain the quadruped tilts significantly; don't terminate on
+  # orientation alone. Let out_of_terrain_bounds handle resets.
+  cfg.terminations.pop("fell_over", None)
+
+  cfg.terminations["illegal_contact"] = TerminationTermCfg(
+    func=mdp.illegal_contact,
+    params={"sensor_name": thigh_ground_cfg.name},
+  )
+
+  # Apply play mode overrides.
+  if play:
+    # Effectively infinite episode length.
+    cfg.episode_length_s = int(1e9)
+
+    cfg.observations["actor"].enable_corruption = False
+    cfg.events.pop("push_robot", None)
+    cfg.terminations.pop("out_of_terrain_bounds", None)
+    cfg.curriculum = {}
+    cfg.events["randomize_terrain"] = EventTermCfg(
+      func=envs_mdp.randomize_terrain,
+      mode="reset",
+      params={},
+    )
+
+    if cfg.scene.terrain is not None:
+      if cfg.scene.terrain.terrain_generator is not None:
+        cfg.scene.terrain.terrain_generator.curriculum = False
+        cfg.scene.terrain.terrain_generator.num_cols = 5
+        cfg.scene.terrain.terrain_generator.num_rows = 5
+        cfg.scene.terrain.terrain_generator.border_width = 10.0
+
+  return cfg
+
+
+def unitree_go1_flat_env_cfg(play: bool = False) -> ManagerBasedRlEnvCfg:
+  """Create Unitree Go1 flat terrain velocity configuration."""
+  cfg = unitree_go1_rough_env_cfg(play=play)
+
+  cfg.sim.njmax = 300
+  cfg.sim.mujoco.ccd_iterations = 50
+  cfg.sim.contact_sensor_maxmatch = 64
+  cfg.sim.nconmax = None
+
+  # Switch to flat terrain.
+  assert cfg.scene.terrain is not None
+  cfg.scene.terrain.terrain_type = "plane"
+  cfg.scene.terrain.terrain_generator = None
+
+  # Remove raycast sensors and collision sensors not needed on flat.
+  remove_sensors = {
+    "terrain_scan",
+    "self_collision",
+    "thigh_ground_touch",
+    "shank_ground_touch",
+    "trunk_ground_touch",
+  }
+  cfg.scene.sensors = tuple(
+    s for s in (cfg.scene.sensors or ()) if s.name not in remove_sensors
+  )
+  del cfg.observations["actor"].terms["height_scan"]
+  del cfg.observations["critic"].terms["height_scan"]
+  cfg.rewards["upright"].params.pop("terrain_sensor_names", None)
+
+  # Remove granular collision rewards (not useful on flat ground).
+  for key in ("self_collisions", "shank_collision", "trunk_head_collision"):
+    cfg.rewards.pop(key, None)
+
+  # On flat terrain fell_over is sufficient; thigh contact implies fallen.
+  cfg.terminations.pop("illegal_contact", None)
+  cfg.terminations.pop("out_of_terrain_bounds", None)
+  cfg.terminations["fell_over"] = TerminationTermCfg(
+    func=mdp.bad_orientation,
+    params={"limit_angle": math.radians(70.0)},
+  )
+
+  # Disable terrain curriculum (not present in play mode since rough clears all).
+  cfg.curriculum.pop("terrain_levels", None)
+
+  if play:
+    twist_cmd = cfg.commands["twist"]
+    assert isinstance(twist_cmd, UniformVelocityCommandCfg)
+    twist_cmd.ranges.lin_vel_x = (-1.5, 2.0)
+    twist_cmd.ranges.ang_vel_z = (-0.7, 0.7)
+
+  return cfg
diff --git a/src/mjlab/tasks/velocity/config/go1/rl_cfg.py b/src/mjlab/tasks/velocity/config/go1/rl_cfg.py
new file mode 100644
index 0000000..56ce112
--- /dev/null
+++ b/src/mjlab/tasks/velocity/config/go1/rl_cfg.py
@@ -0,0 +1,46 @@
+"""RL configuration for Unitree Go1 velocity task."""
+
+from mjlab.rl import (
+  RslRlModelCfg,
+  RslRlOnPolicyRunnerCfg,
+  RslRlPpoAlgorithmCfg,
+)
+
+
+def unitree_go1_ppo_runner_cfg() -> RslRlOnPolicyRunnerCfg:
+  """Create RL runner configuration for Unitree Go1 velocity task."""
+  return RslRlOnPolicyRunnerCfg(
+    actor=RslRlModelCfg(
+      hidden_dims=(512, 256, 128),
+      activation="elu",
+      obs_normalization=True,
+      distribution_cfg={
+        "class_name": "GaussianDistribution",
+        "init_std": 1.0,
+        "std_type": "scalar",
+      },
+    ),
+    critic=RslRlModelCfg(
+      hidden_dims=(512, 256, 128),
+      activation="elu",
+      obs_normalization=True,
+    ),
+    algorithm=RslRlPpoAlgorithmCfg(
+      value_loss_coef=1.0,
+      use_clipped_value_loss=True,
+      clip_param=0.2,
+      entropy_coef=0.01,
+      num_learning_epochs=5,
+      num_mini_batches=4,
+      learning_rate=1.0e-3,
+      schedule="adaptive",
+      gamma=0.99,
+      lam=0.95,
+      desired_kl=0.01,
+      max_grad_norm=1.0,
+    ),
+    experiment_name="go1_velocity",
+    save_interval=50,
+    num_steps_per_env=24,
+    max_iterations=10_000,
+  )
diff --git a/src/mjlab/tasks/velocity/mdp/__init__.py b/src/mjlab/tasks/velocity/mdp/__init__.py
new file mode 100644
index 0000000..1d3be52
--- /dev/null
+++ b/src/mjlab/tasks/velocity/mdp/__init__.py
@@ -0,0 +1,7 @@
+from mjlab.envs.mdp import *  # noqa: F401, F403
+
+from .curriculums import *  # noqa: F403
+from .observations import *  # noqa: F403
+from .rewards import *  # noqa: F403
+from .terminations import *  # noqa: F403
+from .velocity_command import *  # noqa: F403
diff --git a/src/mjlab/tasks/velocity/mdp/curriculums.py b/src/mjlab/tasks/velocity/mdp/curriculums.py
new file mode 100644
index 0000000..3ae1d46
--- /dev/null
+++ b/src/mjlab/tasks/velocity/mdp/curriculums.py
@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, TypedDict, cast
+
+import torch
+
+from mjlab.entity import Entity
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+from .velocity_command import UniformVelocityCommandCfg
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+_DEFAULT_SCENE_CFG = SceneEntityCfg("robot")
+
+
+class VelocityStage(TypedDict):
+  step: int
+  lin_vel_x: tuple[float, float] | None
+  lin_vel_y: tuple[float, float] | None
+  ang_vel_z: tuple[float, float] | None
+
+
+def terrain_levels_vel(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor,
+  command_name: str,
+  asset_cfg: SceneEntityCfg = _DEFAULT_SCENE_CFG,
+) -> dict[str, torch.Tensor]:
+  asset: Entity = env.scene[asset_cfg.name]
+
+  terrain = env.scene.terrain
+  assert terrain is not None
+  terrain_generator = terrain.cfg.terrain_generator
+  assert terrain_generator is not None
+
+  command = env.command_manager.get_command(command_name)
+  assert command is not None
+
+  # Compute the distance the robot walked.
+  distance = torch.norm(
+    asset.data.root_link_pos_w[env_ids, :2] - env.scene.env_origins[env_ids, :2],
+    dim=1,
+  )
+
+  # Robots that walked far enough progress to harder terrains.
+  move_up = distance > terrain_generator.size[0] / 2
+
+  # Robots that walked less than half of their required distance go to
+  # simpler terrains.
+  move_down = (
+    distance < torch.norm(command[env_ids, :2], dim=1) * env.max_episode_length_s * 0.5
+  )
+  move_down *= ~move_up
+
+  # On the initial reset (before any env step) the robot is still at its spawn
+  # pose rather than a walked-to position, so ``distance`` is meaningless and
+  # would spuriously promote every env from level 0 to 1, ignoring
+  # ``max_init_terrain_level``. Freeze levels on that first reset.
+  if env.common_step_counter == 0:
+    move_up = torch.zeros_like(move_up)
+    move_down = torch.zeros_like(move_down)
+
+  # Update terrain levels.
+  terrain.update_env_origins(env_ids, move_up, move_down)
+
+  # Compute per-terrain-type mean levels.
+  levels = terrain.terrain_levels.float()
+  result: dict[str, torch.Tensor] = {
+    "mean": torch.mean(levels),
+    "max": torch.max(levels),
+  }
+
+  # In curriculum mode num_cols == num_terrains (one column per type),
+  # so the column index directly maps to the sub-terrain name.
+  sub_terrain_names = list(terrain_generator.sub_terrains.keys())
+  terrain_origins = terrain.terrain_origins
+  assert terrain_origins is not None
+  num_cols = terrain_origins.shape[1]
+  if num_cols == len(sub_terrain_names):
+    types = terrain.terrain_types
+    for i, name in enumerate(sub_terrain_names):
+      mask = types == i
+      if mask.any():
+        result[name] = torch.mean(levels[mask])
+
+  return result
+
+
+def commands_vel(
+  env: ManagerBasedRlEnv,
+  env_ids: torch.Tensor,
+  command_name: str,
+  velocity_stages: list[VelocityStage],
+) -> dict[str, torch.Tensor]:
+  del env_ids  # Unused.
+  command_term = env.command_manager.get_term(command_name)
+  assert command_term is not None
+  cfg = cast(UniformVelocityCommandCfg, command_term.cfg)
+  for stage in velocity_stages:
+    if env.common_step_counter >= stage["step"]:
+      if "lin_vel_x" in stage and stage["lin_vel_x"] is not None:
+        cfg.ranges.lin_vel_x = stage["lin_vel_x"]
+      if "lin_vel_y" in stage and stage["lin_vel_y"] is not None:
+        cfg.ranges.lin_vel_y = stage["lin_vel_y"]
+      if "ang_vel_z" in stage and stage["ang_vel_z"] is not None:
+        cfg.ranges.ang_vel_z = stage["ang_vel_z"]
+  return {
+    "lin_vel_x_min": torch.tensor(cfg.ranges.lin_vel_x[0]),
+    "lin_vel_x_max": torch.tensor(cfg.ranges.lin_vel_x[1]),
+    "lin_vel_y_min": torch.tensor(cfg.ranges.lin_vel_y[0]),
+    "lin_vel_y_max": torch.tensor(cfg.ranges.lin_vel_y[1]),
+    "ang_vel_z_min": torch.tensor(cfg.ranges.ang_vel_z[0]),
+    "ang_vel_z_max": torch.tensor(cfg.ranges.ang_vel_z[1]),
+  }
diff --git a/src/mjlab/tasks/velocity/mdp/observations.py b/src/mjlab/tasks/velocity/mdp/observations.py
new file mode 100644
index 0000000..6275d43
--- /dev/null
+++ b/src/mjlab/tasks/velocity/mdp/observations.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.sensor import ContactSensor
+from mjlab.sensor.terrain_height_sensor import TerrainHeightSensor
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+def foot_height(env: ManagerBasedRlEnv, sensor_name: str) -> torch.Tensor:
+  """Per-foot vertical clearance above terrain.
+
+  Returns:
+    Tensor of shape [B, F] where F is the number of frames (feet).
+  """
+  sensor = env.scene[sensor_name]
+  assert isinstance(sensor, TerrainHeightSensor), (
+    f"foot_height requires a TerrainHeightSensor, got {type(sensor).__name__}"
+  )
+  return sensor.data.heights
+
+
+def foot_air_time(env: ManagerBasedRlEnv, sensor_name: str) -> torch.Tensor:
+  sensor: ContactSensor = env.scene[sensor_name]
+  sensor_data = sensor.data
+  current_air_time = sensor_data.current_air_time
+  assert current_air_time is not None
+  return current_air_time
+
+
+def foot_contact(env: ManagerBasedRlEnv, sensor_name: str) -> torch.Tensor:
+  sensor: ContactSensor = env.scene[sensor_name]
+  sensor_data = sensor.data
+  assert sensor_data.found is not None
+  return (sensor_data.found > 0).float()
+
+
+def foot_contact_forces(env: ManagerBasedRlEnv, sensor_name: str) -> torch.Tensor:
+  sensor: ContactSensor = env.scene[sensor_name]
+  sensor_data = sensor.data
+  assert sensor_data.force is not None
+  forces_flat = sensor_data.force.flatten(start_dim=1)  # [B, N*3]
+  return torch.sign(forces_flat) * torch.log1p(torch.abs(forces_flat))
diff --git a/src/mjlab/tasks/velocity/mdp/rewards.py b/src/mjlab/tasks/velocity/mdp/rewards.py
new file mode 100644
index 0000000..12fc9d9
--- /dev/null
+++ b/src/mjlab/tasks/velocity/mdp/rewards.py
@@ -0,0 +1,466 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+import torch
+
+from mjlab.entity import Entity
+from mjlab.managers.reward_manager import RewardTermCfg
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.sensor import BuiltinSensor, ContactSensor
+from mjlab.sensor.terrain_height_sensor import TerrainHeightSensor
+from mjlab.tasks.velocity.mdp.terrain_utils import terrain_normal_from_sensors
+from mjlab.utils.lab_api.math import quat_apply, quat_apply_inverse
+from mjlab.utils.lab_api.string import (
+  resolve_matching_names_values,
+)
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+  from mjlab.viewer.debug_visualizer import DebugVisualizer
+
+
+_DEFAULT_ASSET_CFG = SceneEntityCfg("robot")
+
+
+def track_linear_velocity(
+  env: ManagerBasedRlEnv,
+  std: float,
+  command_name: str,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  """Reward for tracking the commanded base linear velocity.
+
+  The commanded z velocity is assumed to be zero.
+  """
+  asset: Entity = env.scene[asset_cfg.name]
+  command = env.command_manager.get_command(command_name)
+  assert command is not None, f"Command '{command_name}' not found."
+  actual = asset.data.root_link_lin_vel_b
+  xy_error = torch.sum(torch.square(command[:, :2] - actual[:, :2]), dim=1)
+  z_error = torch.square(actual[:, 2])
+  lin_vel_error = xy_error + z_error
+  return torch.exp(-lin_vel_error / std**2)
+
+
+def track_angular_velocity(
+  env: ManagerBasedRlEnv,
+  std: float,
+  command_name: str,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  """Reward heading error for heading-controlled envs, angular velocity for others.
+
+  The commanded xy angular velocities are assumed to be zero.
+  """
+  asset: Entity = env.scene[asset_cfg.name]
+  command = env.command_manager.get_command(command_name)
+  assert command is not None, f"Command '{command_name}' not found."
+  actual = asset.data.root_link_ang_vel_b
+  z_error = torch.square(command[:, 2] - actual[:, 2])
+  xy_error = torch.sum(torch.square(actual[:, :2]), dim=1)
+  ang_vel_error = z_error + xy_error
+  return torch.exp(-ang_vel_error / std**2)
+
+
+class upright:
+  """Reward for keeping the base upright.
+
+  Without ``terrain_sensor_names``, penalizes tilt relative to world up (correct for
+  flat ground).
+
+  With ``terrain_sensor_names``, penalizes tilt relative to the terrain surface normal.
+  """
+
+  def __init__(self, cfg: RewardTermCfg, env: ManagerBasedRlEnv):
+    self._terrain_sensor_names: tuple[str, ...] | None = cfg.params.get(
+      "terrain_sensor_names"
+    )
+    self._debug_vis_enabled = True
+    self._env = env
+    self._asset_cfg: SceneEntityCfg = cfg.params.get("asset_cfg", _DEFAULT_ASSET_CFG)
+
+  def __call__(
+    self,
+    env: ManagerBasedRlEnv,
+    std: float,
+    asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+    terrain_sensor_names: tuple[str, ...] | None = None,
+  ) -> torch.Tensor:
+    asset: Entity = env.scene[asset_cfg.name]
+
+    if asset_cfg.body_ids:
+      body_quat_w = asset.data.body_link_quat_w[:, asset_cfg.body_ids, :]  # [B, N, 4]
+      body_quat_w = body_quat_w.squeeze(1)  # [B, 4]
+    else:
+      body_quat_w = asset.data.root_link_quat_w  # [B, 4]
+
+    if terrain_sensor_names is not None:
+      terrain_normal = terrain_normal_from_sensors(env, terrain_sensor_names)  # [B, 3]
+      # Project terrain normal into body frame. When aligned with the terrain surface
+      # this should be (0, 0, 1); XY measures tilt.
+      target_b = quat_apply_inverse(body_quat_w, terrain_normal)  # [B, 3]
+      xy_squared = torch.sum(torch.square(target_b[:, :2]), dim=1)
+    else:
+      gravity_w = asset.data.gravity_vec_w  # [3]
+      projected_gravity_b = quat_apply_inverse(body_quat_w, gravity_w)
+      xy_squared = torch.sum(torch.square(projected_gravity_b[:, :2]), dim=1)
+
+    return torch.exp(-xy_squared / std**2)
+
+  def reset(self, env_ids: torch.Tensor) -> None:
+    del env_ids  # Unused.
+
+  def debug_vis(self, visualizer: DebugVisualizer) -> None:
+    if not self._debug_vis_enabled or self._terrain_sensor_names is None:
+      return
+
+    env = self._env
+    asset: Entity = env.scene[self._asset_cfg.name]
+
+    env_indices = list(visualizer.get_env_indices(env.num_envs))
+    if not env_indices:
+      return
+
+    terrain_normal = terrain_normal_from_sensors(env, self._terrain_sensor_names)
+    if self._asset_cfg.body_ids:
+      body_quat_w = asset.data.body_link_quat_w[:, self._asset_cfg.body_ids, :].squeeze(
+        1
+      )
+    else:
+      body_quat_w = asset.data.root_link_quat_w
+    up_local = torch.tensor([0.0, 0.0, 1.0], device=env.device).expand_as(
+      body_quat_w[:, :3]
+    )
+    body_up_w = quat_apply(body_quat_w, up_local)
+
+    positions = asset.data.root_link_pos_w.cpu().numpy()
+    offset = np.array([0.0, 0.3, 0.0])
+    terrain_normal_np = terrain_normal.cpu().numpy()
+    body_up_np = body_up_w.cpu().numpy()
+    scale = 0.25
+
+    for i in env_indices:
+      origin = positions[i] + offset
+      # Terrain normal (magenta).
+      visualizer.add_arrow(
+        start=origin,
+        end=origin + terrain_normal_np[i] * scale,
+        color=(0.8, 0.2, 0.8, 0.8),
+        width=0.01,
+      )
+      # Body up (orange).
+      visualizer.add_arrow(
+        start=origin,
+        end=origin + body_up_np[i] * scale,
+        color=(1.0, 0.5, 0.0, 0.8),
+        width=0.01,
+      )
+
+
+def self_collision_cost(
+  env: ManagerBasedRlEnv,
+  sensor_name: str,
+  force_threshold: float = 10.0,
+) -> torch.Tensor:
+  """Penalize self-collisions.
+
+  When the sensor provides force history (from ``history_length > 0``),
+  counts substeps where any contact force exceeds *force_threshold*.
+  Falls back to the instantaneous ``found`` count otherwise.
+  """
+  sensor: ContactSensor = env.scene[sensor_name]
+  data = sensor.data
+  if data.force_history is not None:
+    # force_history: [B, N, H, 3]
+    force_mag = torch.norm(data.force_history, dim=-1)  # [B, N, H]
+    hit = (force_mag > force_threshold).any(dim=1)  # [B, H]
+    return hit.sum(dim=-1).float()  # [B]
+  assert data.found is not None
+  return data.found.sum(dim=-1).float()
+
+
+def body_angular_velocity_penalty(
+  env: ManagerBasedRlEnv,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  """Penalize excessive body angular velocities."""
+  asset: Entity = env.scene[asset_cfg.name]
+  ang_vel = asset.data.body_link_ang_vel_w[:, asset_cfg.body_ids, :]
+  ang_vel = ang_vel.squeeze(1)
+  ang_vel_xy = ang_vel[:, :2]  # Don't penalize z-angular velocity.
+  return torch.sum(torch.square(ang_vel_xy), dim=1)
+
+
+def angular_momentum_penalty(
+  env: ManagerBasedRlEnv,
+  sensor_name: str,
+) -> torch.Tensor:
+  """Penalize whole-body angular momentum to encourage natural arm swing."""
+  angmom_sensor: BuiltinSensor = env.scene[sensor_name]
+  angmom = angmom_sensor.data
+  angmom_magnitude_sq = torch.sum(torch.square(angmom), dim=-1)
+  angmom_magnitude = torch.sqrt(angmom_magnitude_sq)
+  env.extras["log"]["Metrics/angular_momentum_mean"] = torch.mean(angmom_magnitude)
+  return angmom_magnitude_sq
+
+
+def feet_air_time(
+  env: ManagerBasedRlEnv,
+  sensor_name: str,
+  threshold_min: float = 0.05,
+  threshold_max: float = 0.5,
+  command_name: str | None = None,
+  command_threshold: float = 0.5,
+) -> torch.Tensor:
+  """Reward feet air time."""
+  sensor: ContactSensor = env.scene[sensor_name]
+  sensor_data = sensor.data
+  current_air_time = sensor_data.current_air_time
+  assert current_air_time is not None
+  in_range = (current_air_time > threshold_min) & (current_air_time < threshold_max)
+  reward = torch.sum(in_range.float(), dim=1)
+  in_air = current_air_time > 0
+  num_in_air = torch.sum(in_air.float())
+  mean_air_time = torch.sum(current_air_time * in_air.float()) / torch.clamp(
+    num_in_air, min=1
+  )
+  env.extras["log"]["Metrics/air_time_mean"] = mean_air_time
+  if command_name is not None:
+    command = env.command_manager.get_command(command_name)
+    if command is not None:
+      linear_norm = torch.norm(command[:, :2], dim=1)
+      angular_norm = torch.abs(command[:, 2])
+      total_command = linear_norm + angular_norm
+      scale = (total_command > command_threshold).float()
+      reward *= scale
+  return reward
+
+
+def feet_clearance(
+  env: ManagerBasedRlEnv,
+  target_height: float,
+  height_sensor_name: str,
+  command_name: str | None = None,
+  command_threshold: float = 0.01,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  """Penalize deviation from target clearance height, weighted by foot velocity."""
+  asset: Entity = env.scene[asset_cfg.name]
+  height_sensor = env.scene[height_sensor_name]
+  assert isinstance(height_sensor, TerrainHeightSensor), (
+    f"feet_clearance requires a TerrainHeightSensor, got {type(height_sensor).__name__}"
+  )
+  foot_height = height_sensor.data.heights  # [B, F]
+  foot_vel_xy = asset.data.site_lin_vel_w[:, asset_cfg.site_ids, :2]  # [B, F, 2]
+  vel_norm = torch.norm(foot_vel_xy, dim=-1)  # [B, F]
+  delta = torch.abs(foot_height - target_height)  # [B, F]
+  cost = torch.sum(delta * vel_norm, dim=1)  # [B]
+  if command_name is not None:
+    command = env.command_manager.get_command(command_name)
+    if command is not None:
+      linear_norm = torch.norm(command[:, :2], dim=1)
+      angular_norm = torch.abs(command[:, 2])
+      total_command = linear_norm + angular_norm
+      active = (total_command > command_threshold).float()
+      cost = cost * active
+  return cost
+
+
+class feet_swing_height:
+  """Penalize deviation from target swing height, evaluated at landing."""
+
+  def __init__(self, cfg: RewardTermCfg, env: ManagerBasedRlEnv):
+    height_sensor = env.scene[cfg.params["height_sensor_name"]]
+    assert isinstance(height_sensor, TerrainHeightSensor), (
+      f"feet_swing_height requires a TerrainHeightSensor, got {type(height_sensor).__name__}"
+    )
+    num_feet = height_sensor.num_frames
+    self.peak_heights = torch.zeros(
+      (env.num_envs, num_feet), device=env.device, dtype=torch.float32
+    )
+    self.step_dt = env.step_dt
+
+  def __call__(
+    self,
+    env: ManagerBasedRlEnv,
+    sensor_name: str,
+    height_sensor_name: str,
+    target_height: float,
+    command_name: str,
+    command_threshold: float,
+  ) -> torch.Tensor:
+    contact_sensor: ContactSensor = env.scene[sensor_name]
+    command = env.command_manager.get_command(command_name)
+    assert command is not None
+    height_sensor: TerrainHeightSensor = env.scene[height_sensor_name]
+    foot_heights = height_sensor.data.heights
+    in_air = contact_sensor.data.found == 0
+    self.peak_heights = torch.where(
+      in_air,
+      torch.maximum(self.peak_heights, foot_heights),
+      self.peak_heights,
+    )
+    first_contact = contact_sensor.compute_first_contact(dt=self.step_dt)
+    linear_norm = torch.norm(command[:, :2], dim=1)
+    angular_norm = torch.abs(command[:, 2])
+    total_command = linear_norm + angular_norm
+    active = (total_command > command_threshold).float()
+    error = self.peak_heights / target_height - 1.0
+    cost = torch.sum(torch.square(error) * first_contact.float(), dim=1) * active
+    num_landings = torch.sum(first_contact.float())
+    peak_heights_at_landing = self.peak_heights * first_contact.float()
+    mean_peak_height = torch.sum(peak_heights_at_landing) / torch.clamp(
+      num_landings, min=1
+    )
+    env.extras["log"]["Metrics/peak_height_mean"] = mean_peak_height
+    self.peak_heights = torch.where(
+      first_contact,
+      torch.zeros_like(self.peak_heights),
+      self.peak_heights,
+    )
+    return cost
+
+
+def feet_slip(
+  env: ManagerBasedRlEnv,
+  sensor_name: str,
+  command_name: str,
+  command_threshold: float = 0.01,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  """Penalize foot sliding (xy velocity while in contact)."""
+  asset: Entity = env.scene[asset_cfg.name]
+  contact_sensor: ContactSensor = env.scene[sensor_name]
+  command = env.command_manager.get_command(command_name)
+  assert command is not None
+  linear_norm = torch.norm(command[:, :2], dim=1)
+  angular_norm = torch.abs(command[:, 2])
+  total_command = linear_norm + angular_norm
+  active = (total_command > command_threshold).float()
+  assert contact_sensor.data.found is not None
+  in_contact = (contact_sensor.data.found > 0).float()  # [B, N]
+  foot_vel_xy = asset.data.site_lin_vel_w[:, asset_cfg.site_ids, :2]  # [B, N, 2]
+  vel_xy_norm = torch.norm(foot_vel_xy, dim=-1)  # [B, N]
+  vel_xy_norm_sq = torch.square(vel_xy_norm)  # [B, N]
+  cost = torch.sum(vel_xy_norm_sq * in_contact, dim=1) * active
+  num_in_contact = torch.sum(in_contact)
+  mean_slip_vel = torch.sum(vel_xy_norm * in_contact) / torch.clamp(
+    num_in_contact, min=1
+  )
+  env.extras["log"]["Metrics/slip_velocity_mean"] = mean_slip_vel
+  return cost
+
+
+def soft_landing(
+  env: ManagerBasedRlEnv,
+  sensor_name: str,
+  command_name: str | None = None,
+  command_threshold: float = 0.05,
+) -> torch.Tensor:
+  """Penalize high impact forces at landing to encourage soft footfalls."""
+  contact_sensor: ContactSensor = env.scene[sensor_name]
+  sensor_data = contact_sensor.data
+  assert sensor_data.force is not None
+  forces = sensor_data.force  # [B, N, 3]
+  force_magnitude = torch.norm(forces, dim=-1)  # [B, N]
+  first_contact = contact_sensor.compute_first_contact(dt=env.step_dt)  # [B, N]
+  landing_impact = force_magnitude * first_contact.float()  # [B, N]
+  cost = torch.sum(landing_impact, dim=1)  # [B]
+  num_landings = torch.sum(first_contact.float())
+  mean_landing_force = torch.sum(landing_impact) / torch.clamp(num_landings, min=1)
+  env.extras["log"]["Metrics/landing_force_mean"] = mean_landing_force
+  if command_name is not None:
+    command = env.command_manager.get_command(command_name)
+    if command is not None:
+      linear_norm = torch.norm(command[:, :2], dim=1)
+      angular_norm = torch.abs(command[:, 2])
+      total_command = linear_norm + angular_norm
+      active = (total_command > command_threshold).float()
+      cost = cost * active
+  return cost
+
+
+class variable_posture:
+  """Penalize deviation from default pose with speed-dependent tolerance.
+
+  Uses per-joint standard deviations to control how much each joint can deviate
+  from default pose. Smaller std = stricter (less deviation allowed), larger
+  std = more forgiving. The reward is: exp(-mean(error² / std²))
+
+  Three speed regimes (based on linear + angular command velocity):
+    - std_standing (speed < walking_threshold): Tight tolerance for holding pose.
+    - std_walking (walking_threshold <= speed < running_threshold): Moderate.
+    - std_running (speed >= running_threshold): Loose tolerance for large motion.
+
+  Tune std values per joint based on how much motion that joint needs at each
+  speed. Map joint name patterns to std values, e.g. {".*knee.*": 0.35}.
+  """
+
+  def __init__(self, cfg: RewardTermCfg, env: ManagerBasedRlEnv):
+    asset: Entity = env.scene[cfg.params["asset_cfg"].name]
+    default_joint_pos = asset.data.default_joint_pos
+    assert default_joint_pos is not None
+    self.default_joint_pos = default_joint_pos
+
+    _, joint_names = asset.find_joints(cfg.params["asset_cfg"].joint_names)
+
+    _, _, std_standing = resolve_matching_names_values(
+      data=cfg.params["std_standing"],
+      list_of_strings=joint_names,
+    )
+    self.std_standing = torch.tensor(
+      std_standing, device=env.device, dtype=torch.float32
+    )
+
+    _, _, std_walking = resolve_matching_names_values(
+      data=cfg.params["std_walking"],
+      list_of_strings=joint_names,
+    )
+    self.std_walking = torch.tensor(std_walking, device=env.device, dtype=torch.float32)
+
+    _, _, std_running = resolve_matching_names_values(
+      data=cfg.params["std_running"],
+      list_of_strings=joint_names,
+    )
+    self.std_running = torch.tensor(std_running, device=env.device, dtype=torch.float32)
+
+  def __call__(
+    self,
+    env: ManagerBasedRlEnv,
+    std_standing,
+    std_walking,
+    std_running,
+    asset_cfg: SceneEntityCfg,
+    command_name: str,
+    walking_threshold: float = 0.5,
+    running_threshold: float = 1.5,
+  ) -> torch.Tensor:
+    del std_standing, std_walking, std_running  # Unused.
+
+    asset: Entity = env.scene[asset_cfg.name]
+    command = env.command_manager.get_command(command_name)
+    assert command is not None
+
+    linear_speed = torch.norm(command[:, :2], dim=1)
+    angular_speed = torch.abs(command[:, 2])
+    total_speed = linear_speed + angular_speed
+
+    standing_mask = (total_speed < walking_threshold).float()
+    walking_mask = (
+      (total_speed >= walking_threshold) & (total_speed < running_threshold)
+    ).float()
+    running_mask = (total_speed >= running_threshold).float()
+
+    std = (
+      self.std_standing * standing_mask.unsqueeze(1)
+      + self.std_walking * walking_mask.unsqueeze(1)
+      + self.std_running * running_mask.unsqueeze(1)
+    )
+
+    current_joint_pos = asset.data.joint_pos[:, asset_cfg.joint_ids]
+    desired_joint_pos = self.default_joint_pos[:, asset_cfg.joint_ids]
+    error_squared = torch.square(current_joint_pos - desired_joint_pos)
+
+    return torch.exp(-torch.mean(error_squared / (std**2), dim=1))
diff --git a/src/mjlab/tasks/velocity/mdp/terminations.py b/src/mjlab/tasks/velocity/mdp/terminations.py
new file mode 100644
index 0000000..a5c81fc
--- /dev/null
+++ b/src/mjlab/tasks/velocity/mdp/terminations.py
@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.entity import Entity
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.sensor import ContactSensor
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+_DEFAULT_ASSET_CFG = SceneEntityCfg("robot")
+
+
+def illegal_contact(
+  env: ManagerBasedRlEnv,
+  sensor_name: str,
+  force_threshold: float = 10.0,
+) -> torch.Tensor:
+  sensor: ContactSensor = env.scene[sensor_name]
+  data = sensor.data
+  if data.force_history is not None:
+    # force_history: [B, N, H, 3]
+    force_mag = torch.norm(data.force_history, dim=-1)  # [B, N, H]
+    return (force_mag > force_threshold).any(dim=-1).any(dim=-1)  # [B]
+  assert data.found is not None
+  return torch.any(data.found, dim=-1)
+
+
+def out_of_terrain_bounds(
+  env: ManagerBasedRlEnv,
+  margin: float = 0.3,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  """Truncate if robot leaves the generated terrain footprint.
+
+  Returns all-false for non-generator terrains (e.g. plane).
+  """
+  terrain = env.scene.terrain
+  if terrain is None or terrain.cfg.terrain_type != "generator":
+    return torch.zeros(
+      (env.num_envs,),
+      device=env.device,
+      dtype=torch.bool,
+    )
+
+  terrain_generator = terrain.cfg.terrain_generator
+  if terrain_generator is None or terrain.terrain_origins is None:
+    return torch.zeros(
+      (env.num_envs,),
+      device=env.device,
+      dtype=torch.bool,
+    )
+
+  asset: Entity = env.scene[asset_cfg.name]
+  root_xy_w = asset.data.root_link_pos_w[:, :2]
+
+  # Use the generated grid shape (curriculum mode overrides cfg.num_cols with
+  # len(sub_terrains)), and include the flat border around the patch grid.
+  num_rows, num_cols = terrain.terrain_origins.shape[:2]
+  half_x = 0.5 * (num_rows * terrain_generator.size[0]) + terrain_generator.border_width
+  half_y = 0.5 * (num_cols * terrain_generator.size[1]) + terrain_generator.border_width
+  limit_x = max(0.0, half_x - margin)
+  limit_y = max(0.0, half_y - margin)
+
+  return (root_xy_w[:, 0].abs() > limit_x) | (root_xy_w[:, 1].abs() > limit_y)
+
+
+def terrain_edge_reached(
+  env: ManagerBasedRlEnv,
+  threshold_fraction: float = 0.95,
+  asset_cfg: SceneEntityCfg = _DEFAULT_ASSET_CFG,
+) -> torch.Tensor:
+  """Terminate when robot displacement from spawn exceeds sub-terrain size.
+
+  Intended as ``time_out=True`` (successful traversal, not penalized). Skips the first
+  2 steps after reset to avoid stale-position triggers.
+  """
+  terrain = env.scene.terrain
+  if terrain is None or terrain.cfg.terrain_type != "generator":
+    return torch.zeros(env.num_envs, device=env.device, dtype=torch.bool)
+
+  terrain_generator = terrain.cfg.terrain_generator
+  if terrain_generator is None:
+    return torch.zeros(env.num_envs, device=env.device, dtype=torch.bool)
+
+  asset: Entity = env.scene[asset_cfg.name]
+  displacement = (
+    asset.data.root_link_pos_w[:, :2] - env.scene.env_origins[:, :2]
+  ).abs()
+
+  half_x = terrain_generator.size[0] / 2.0 * threshold_fraction
+  half_y = terrain_generator.size[1] / 2.0 * threshold_fraction
+
+  at_edge = (displacement[:, 0] > half_x) | (displacement[:, 1] > half_y)
+
+  # Don't fire on the first 2 steps after reset (position may be stale).
+  at_edge &= env.episode_length_buf > 2
+
+  return at_edge
diff --git a/src/mjlab/tasks/velocity/mdp/terrain_utils.py b/src/mjlab/tasks/velocity/mdp/terrain_utils.py
new file mode 100644
index 0000000..232c237
--- /dev/null
+++ b/src/mjlab/tasks/velocity/mdp/terrain_utils.py
@@ -0,0 +1,123 @@
+"""Terrain normal estimation from raycast hit points."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from mjlab.sensor import RayCastSensor
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+def fit_terrain_normal(
+  points: torch.Tensor,
+  valid_mask: torch.Tensor,
+) -> torch.Tensor:
+  """Fit a plane normal from 3D points via covariance eigendecomposition.
+
+  Args:
+    points: [B, N, 3] world-frame positions.
+    valid_mask: [B, N] boolean (True = valid).
+
+  Returns:
+    [B, 3] unit normal oriented upward. Falls back to [0, 0, 1]
+    when fewer than 3 valid points.
+  """
+  B = points.shape[0]
+  device = points.device
+
+  count = valid_mask.sum(dim=1)
+  enough = count >= 3
+
+  mask_f = valid_mask.float().unsqueeze(-1)
+  masked_points = points * mask_f
+  count_clamped = count.clamp(min=1).float().unsqueeze(-1)
+  centroid = masked_points.sum(dim=1) / count_clamped
+  centered = (points - centroid.unsqueeze(1)) * mask_f
+
+  cov = torch.einsum("bni,bnj->bij", centered, centered)
+
+  # ``torch.linalg.eigh`` raises when given non-finite input, so a single env
+  # with a diverged state (NaN/Inf raycast hits) would take down the whole
+  # batch. Replace non-finite covariances with the identity so the decomposition
+  # stays well-defined; these rows fail the reliability check below and fall
+  # back to the up vector.
+  finite = torch.isfinite(cov).all(dim=(-2, -1))
+  eye = torch.eye(3, device=device, dtype=cov.dtype)
+  cov = torch.where(finite.view(-1, 1, 1), cov, eye)
+
+  eigenvalues, eigenvectors = torch.linalg.eigh(cov)
+  normal = eigenvectors[:, :, 0]  # Smallest eigenvalue = plane normal.
+  normal = normal / normal.norm(dim=-1, keepdim=True).clamp(min=1e-8)
+
+  # Orient upward.
+  normal = torch.where((normal[:, 2] < 0).unsqueeze(-1), -normal, normal)
+
+  # Fall back when the fit is degenerate (collinear or near-duplicate
+  # points). A valid plane has one small eigenvalue and two materially
+  # larger ones; line-like or point-like clouds do not.
+  eps = torch.finfo(eigenvalues.dtype).eps
+  plane_like = (eigenvalues[:, 0] / eigenvalues[:, 1].clamp(min=eps)) < 0.1
+  has_spread = eigenvalues[:, 1] > eigenvalues[:, 2].clamp(min=eps) * 1e-6
+  reliable = enough & plane_like & has_spread & finite
+
+  up = torch.tensor([0.0, 0.0, 1.0], device=device).expand(B, 3)
+  return torch.where(reliable.unsqueeze(-1), normal, up)
+
+
+# Cached subsample indices to avoid per-step allocation.
+_subsample_cache: dict[tuple[int, int, torch.device], torch.Tensor] = {}
+
+
+def _subsample_indices(
+  total: int, max_points: int, device: torch.device
+) -> torch.Tensor:
+  key = (total, max_points, device)
+  if key not in _subsample_cache:
+    _subsample_cache[key] = torch.linspace(
+      0, total - 1, max_points, device=device
+    ).long()
+  return _subsample_cache[key]
+
+
+def terrain_normal_from_sensors(
+  env: ManagerBasedRlEnv,
+  sensor_names: tuple[str, ...],
+  max_points: int = 32,
+) -> torch.Tensor:
+  """Estimate terrain normal from one or more raycast sensors.
+
+  Gathers hit positions, subsamples to *max_points* per sensor, and fits a plane
+  normal via :func:`fit_terrain_normal`.
+
+  Returns:
+    [B, 3] unit terrain normal in world frame.
+  """
+  all_points: list[torch.Tensor] = []
+  all_valid: list[torch.Tensor] = []
+
+  for name in sensor_names:
+    sensor = env.scene[name]
+    if not isinstance(sensor, RayCastSensor):
+      raise TypeError(
+        f"Sensor '{name}' is {type(sensor).__name__}, expected RayCastSensor."
+      )
+
+    hit_pos = sensor.data.hit_pos_w
+    valid = sensor.data.distances >= 0
+
+    N = hit_pos.shape[1]
+    if N > max_points:
+      idx = _subsample_indices(N, max_points, hit_pos.device)
+      hit_pos = hit_pos[:, idx]
+      valid = valid[:, idx]
+
+    all_points.append(hit_pos)
+    all_valid.append(valid)
+
+  points = torch.cat(all_points, dim=1)
+  valid_mask = torch.cat(all_valid, dim=1)
+  return fit_terrain_normal(points, valid_mask)
diff --git a/src/mjlab/tasks/velocity/mdp/velocity_command.py b/src/mjlab/tasks/velocity/mdp/velocity_command.py
new file mode 100644
index 0000000..8d0e576
--- /dev/null
+++ b/src/mjlab/tasks/velocity/mdp/velocity_command.py
@@ -0,0 +1,326 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+import torch
+
+from mjlab.entity import Entity
+from mjlab.managers.command_manager import CommandTerm, CommandTermCfg
+from mjlab.utils.lab_api.math import (
+  matrix_from_quat,
+  wrap_to_pi,
+)
+
+if TYPE_CHECKING:
+  import viser
+
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+  from mjlab.viewer.debug_visualizer import DebugVisualizer
+
+
+class UniformVelocityCommand(CommandTerm):
+  cfg: UniformVelocityCommandCfg
+
+  def __init__(self, cfg: UniformVelocityCommandCfg, env: ManagerBasedRlEnv):
+    super().__init__(cfg, env)
+
+    if self.cfg.heading_command and self.cfg.ranges.heading is None:
+      raise ValueError("heading_command=True but ranges.heading is set to None.")
+    if self.cfg.ranges.heading and not self.cfg.heading_command:
+      raise ValueError("ranges.heading is set but heading_command=False.")
+
+    self.robot: Entity = env.scene[cfg.entity_name]
+
+    self.vel_command_b = torch.zeros(self.num_envs, 3, device=self.device)
+    self.vel_command_w = torch.zeros(self.num_envs, 3, device=self.device)
+    self.heading_target = torch.zeros(self.num_envs, device=self.device)
+    self.heading_error = torch.zeros(self.num_envs, device=self.device)
+    self.is_heading_env = torch.zeros(
+      self.num_envs, dtype=torch.bool, device=self.device
+    )
+    self.is_standing_env = torch.zeros_like(self.is_heading_env)
+    self.is_world_env = torch.zeros_like(self.is_heading_env)
+    self.is_forward_env = torch.zeros_like(self.is_heading_env)
+
+    self.metrics["error_vel_xy"] = torch.zeros(self.num_envs, device=self.device)
+    self.metrics["error_vel_yaw"] = torch.zeros(self.num_envs, device=self.device)
+
+    # Set by create_gui() when the viewer is active.
+    self._joystick_enabled: viser.GuiCheckboxHandle | None = None
+    self._joystick_sliders: list[viser.GuiSliderHandle] = []
+    self._joystick_get_env_idx: Callable[[], int] | None = None
+
+  @property
+  def command(self) -> torch.Tensor:
+    return self.vel_command_b
+
+  def _update_metrics(self) -> None:
+    max_command_time = self.cfg.resampling_time_range[1]
+    max_command_step = max_command_time / self._env.step_dt
+    self.metrics["error_vel_xy"] += (
+      torch.norm(
+        self.vel_command_b[:, :2] - self.robot.data.root_link_lin_vel_b[:, :2], dim=-1
+      )
+      / max_command_step
+    )
+    self.metrics["error_vel_yaw"] += (
+      torch.abs(self.vel_command_b[:, 2] - self.robot.data.root_link_ang_vel_b[:, 2])
+      / max_command_step
+    )
+
+  def _resample_command(self, env_ids: torch.Tensor) -> None:
+    r = torch.empty(len(env_ids), device=self.device)
+    self.vel_command_b[env_ids, 0] = r.uniform_(*self.cfg.ranges.lin_vel_x)
+    self.vel_command_b[env_ids, 1] = r.uniform_(*self.cfg.ranges.lin_vel_y)
+    self.vel_command_b[env_ids, 2] = r.uniform_(*self.cfg.ranges.ang_vel_z)
+    if self.cfg.heading_command:
+      assert self.cfg.ranges.heading is not None
+      self.heading_target[env_ids] = r.uniform_(*self.cfg.ranges.heading)
+      self.is_heading_env[env_ids] = r.uniform_(0.0, 1.0) <= self.cfg.rel_heading_envs
+    self.is_standing_env[env_ids] = r.uniform_(0.0, 1.0) <= self.cfg.rel_standing_envs
+
+    # Randomly assign world-frame envs.
+    self.is_world_env[env_ids] = r.uniform_(0.0, 1.0) <= self.cfg.rel_world_envs
+    # Copy sampled velocities as world-frame reference for world envs.
+    self.vel_command_w[env_ids] = self.vel_command_b[env_ids]
+
+    # Forward-only envs: positive lin_vel_x, zero lateral and angular.
+    self.is_forward_env[env_ids] = r.uniform_(0.0, 1.0) <= self.cfg.rel_forward_envs
+    fwd_ids = env_ids[self.is_forward_env[env_ids]]
+    if len(fwd_ids) > 0:
+      self.vel_command_b[fwd_ids, 0] = (
+        self.vel_command_b[fwd_ids, 0].abs().clamp(min=0.3)
+      )
+      self.vel_command_b[fwd_ids, 1] = 0.0
+      self.vel_command_b[fwd_ids, 2] = 0.0
+
+  def reset(self, env_ids: torch.Tensor | slice | None) -> dict[str, float]:
+    extras = super().reset(env_ids)
+    if self.cfg.init_velocity_prob > 0.0:
+      assert isinstance(env_ids, torch.Tensor)
+      r = torch.empty(len(env_ids), device=self.device)
+      init_ids = env_ids[r.uniform_(0.0, 1.0) < self.cfg.init_velocity_prob]
+      if len(init_ids) > 0:
+        # Start these envs already moving at the commanded planar velocity.
+        # Safe pre-forward: the body-frame write reads orientation from qpos.
+        vel_b = torch.zeros(len(init_ids), 6, device=self.device)
+        vel_b[:, :2] = self.vel_command_b[init_ids, :2]
+        vel_b[:, 5] = self.vel_command_b[init_ids, 2]
+        self.robot.write_root_link_velocity_b_to_sim(vel_b, env_ids=init_ids)
+    return extras
+
+  def _update_command(self, env_ids: torch.Tensor | None = None) -> None:
+    # Pure function of the current state; refreshing all envs is safe.
+    del env_ids
+    if self.cfg.heading_command:
+      self.heading_error = wrap_to_pi(self.heading_target - self.robot.data.heading_w)
+      heading_ids = self.is_heading_env.nonzero(as_tuple=False).flatten()
+      self.vel_command_b[heading_ids, 2] = torch.clip(
+        self.cfg.heading_control_stiffness * self.heading_error[heading_ids],
+        min=self.cfg.ranges.ang_vel_z[0],
+        max=self.cfg.ranges.ang_vel_z[1],
+      )
+    # World-frame envs: rotate world-frame linear vel into body frame.
+    if self.is_world_env.any():
+      w_ids = self.is_world_env.nonzero(as_tuple=False).flatten()
+      heading = self.robot.data.heading_w[w_ids]
+      cos_h = torch.cos(heading)
+      sin_h = torch.sin(heading)
+      vx_w = self.vel_command_w[w_ids, 0]
+      vy_w = self.vel_command_w[w_ids, 1]
+      self.vel_command_b[w_ids, 0] = cos_h * vx_w + sin_h * vy_w
+      self.vel_command_b[w_ids, 1] = -sin_h * vx_w + cos_h * vy_w
+
+    standing_env_ids = self.is_standing_env.nonzero(as_tuple=False).flatten()
+    self.vel_command_b[standing_env_ids, :] = 0.0
+    self.vel_command_w[standing_env_ids, :] = 0.0
+
+  # GUI.
+
+  def create_gui(
+    self,
+    name: str,
+    server: viser.ViserServer,
+    get_env_idx: Callable[[], int],
+    on_change: Callable[[], None] | None = None,
+    request_action: Callable[[str, Any], None] | None = None,
+  ) -> None:
+    """Create velocity joystick sliders in the Viser viewer."""
+    from viser import Icon
+
+    ranges = self.cfg.ranges
+
+    axes = [
+      ("lin_vel_x", ranges.lin_vel_x[1]),
+      ("lin_vel_y", ranges.lin_vel_y[1]),
+      ("ang_vel_z", ranges.ang_vel_z[1]),
+    ]
+    sliders: list = []
+
+    with server.gui.add_folder(name.capitalize()):
+      enabled = server.gui.add_checkbox("Enable", initial_value=False)
+
+      for label, max_val in axes:
+        max_input = server.gui.add_slider(
+          f"Max {label}",
+          initial_value=max_val,
+          step=0.1,
+          min=0.1,
+          max=10.0,
+        )
+        slider = server.gui.add_slider(
+          label,
+          min=-max_val,
+          max=max_val,
+          step=0.05,
+          initial_value=0.0,
+        )
+
+        @max_input.on_update
+        def _(_ev, _s=slider, _m=max_input) -> None:
+          _s.min = -_m.value
+          _s.max = _m.value
+
+        sliders.append(slider)
+
+      zero_btn = server.gui.add_button("Zero", icon=Icon.SQUARE_X)
+
+      @zero_btn.on_click
+      def _(_) -> None:
+        for s in sliders:
+          s.value = 0.0
+
+    # Store GUI state for compute() override.
+    self._joystick_enabled = enabled
+    self._joystick_sliders = sliders
+    self._joystick_get_env_idx = get_env_idx
+
+  def compute(
+    self, dt: float | torch.Tensor, env_ids: torch.Tensor | None = None
+  ) -> None:
+    super().compute(dt, env_ids)
+    if self._joystick_enabled is not None and self._joystick_enabled.value:
+      assert self._joystick_get_env_idx is not None
+      idx = self._joystick_get_env_idx()
+      for i, s in enumerate(self._joystick_sliders):
+        self.vel_command_b[idx, i] = s.value
+
+  # Visualization.
+
+  def _debug_vis_impl(self, visualizer: "DebugVisualizer") -> None:
+    """Draw velocity command and actual velocity arrows."""
+    env_indices = visualizer.get_env_indices(self.num_envs)
+    if not env_indices:
+      return
+
+    cmds = self.command.cpu().numpy()
+    base_pos_ws = self.robot.data.root_link_pos_w.cpu().numpy()
+    base_quat_w = self.robot.data.root_link_quat_w
+    base_mat_ws = matrix_from_quat(base_quat_w).cpu().numpy()
+    lin_vel_bs = self.robot.data.root_link_lin_vel_b.cpu().numpy()
+    ang_vel_bs = self.robot.data.root_link_ang_vel_b.cpu().numpy()
+
+    scale = self.cfg.viz.scale
+    z_offset = self.cfg.viz.z_offset
+
+    for batch in env_indices:
+      base_pos_w = base_pos_ws[batch]
+      base_mat_w = base_mat_ws[batch]
+      cmd = cmds[batch]
+      lin_vel_b = lin_vel_bs[batch]
+      ang_vel_b = ang_vel_bs[batch]
+
+      # Skip if robot appears uninitialized (at origin).
+      if np.linalg.norm(base_pos_w) < 1e-6:
+        continue
+
+      # Helper to transform local to world coordinates.
+      def local_to_world(
+        vec: np.ndarray, pos: np.ndarray = base_pos_w, mat: np.ndarray = base_mat_w
+      ) -> np.ndarray:
+        return pos + mat @ vec
+
+      # Command linear velocity arrow (blue).
+      cmd_lin_from = local_to_world(np.array([0, 0, z_offset]) * scale)
+      cmd_lin_to = local_to_world(
+        (np.array([0, 0, z_offset]) + np.array([cmd[0], cmd[1], 0])) * scale
+      )
+      visualizer.add_arrow(
+        cmd_lin_from, cmd_lin_to, color=(0.2, 0.2, 0.6, 0.6), width=0.015
+      )
+
+      # Command angular velocity arrow (green).
+      cmd_ang_from = cmd_lin_from
+      cmd_ang_to = local_to_world(
+        (np.array([0, 0, z_offset]) + np.array([0, 0, cmd[2]])) * scale
+      )
+      visualizer.add_arrow(
+        cmd_ang_from, cmd_ang_to, color=(0.2, 0.6, 0.2, 0.6), width=0.015
+      )
+
+      # Actual linear velocity arrow (cyan).
+      act_lin_from = local_to_world(np.array([0, 0, z_offset]) * scale)
+      act_lin_to = local_to_world(
+        (np.array([0, 0, z_offset]) + np.array([lin_vel_b[0], lin_vel_b[1], 0])) * scale
+      )
+      visualizer.add_arrow(
+        act_lin_from, act_lin_to, color=(0.0, 0.6, 1.0, 0.7), width=0.015
+      )
+
+      # Actual angular velocity arrow (light green).
+      act_ang_from = act_lin_from
+      act_ang_to = local_to_world(
+        (np.array([0, 0, z_offset]) + np.array([0, 0, ang_vel_b[2]])) * scale
+      )
+      visualizer.add_arrow(
+        act_ang_from, act_ang_to, color=(0.0, 1.0, 0.4, 0.7), width=0.015
+      )
+
+
+@dataclass(kw_only=True)
+class UniformVelocityCommandCfg(CommandTermCfg):
+  entity_name: str
+  heading_command: bool = False
+  heading_control_stiffness: float = 1.0
+  rel_standing_envs: float = 0.0
+  rel_heading_envs: float = 1.0
+  rel_world_envs: float = 0.0
+  """Fraction of environments that use world-frame velocity commands.
+  World-frame envs sample linear velocity in world frame and rotate to body
+  frame each step, so the command direction stays fixed in the world."""
+  rel_forward_envs: float = 0.0
+  """Fraction of environments that receive forward-only commands (positive
+  lin_vel_x, zero lin_vel_y and ang_vel_z). Increases training coverage for
+  straight-line walking, which is important for stair climbing."""
+  init_velocity_prob: float = 0.0
+  """Probability that an env starts its episode already moving at its sampled
+  planar command velocity. Applied on reset only."""
+
+  @dataclass
+  class Ranges:
+    lin_vel_x: tuple[float, float]
+    lin_vel_y: tuple[float, float]
+    ang_vel_z: tuple[float, float]
+    heading: tuple[float, float] | None = None
+
+  ranges: Ranges
+
+  @dataclass
+  class VizCfg:
+    z_offset: float = 0.2
+    scale: float = 0.5
+
+  viz: VizCfg = field(default_factory=VizCfg)
+
+  def build(self, env: ManagerBasedRlEnv) -> UniformVelocityCommand:
+    return UniformVelocityCommand(self, env)
+
+  def __post_init__(self):
+    if self.heading_command and self.ranges.heading is None:
+      raise ValueError(
+        "The velocity command has heading commands active (heading_command=True) but "
+        "the `ranges.heading` parameter is set to None."
+      )
diff --git a/src/mjlab/tasks/velocity/rl/__init__.py b/src/mjlab/tasks/velocity/rl/__init__.py
new file mode 100644
index 0000000..ec9b47e
--- /dev/null
+++ b/src/mjlab/tasks/velocity/rl/__init__.py
@@ -0,0 +1,3 @@
+from mjlab.tasks.velocity.rl.runner import (
+  VelocityOnPolicyRunner as VelocityOnPolicyRunner,
+)
diff --git a/src/mjlab/tasks/velocity/rl/runner.py b/src/mjlab/tasks/velocity/rl/runner.py
new file mode 100644
index 0000000..2d682d1
--- /dev/null
+++ b/src/mjlab/tasks/velocity/rl/runner.py
@@ -0,0 +1,27 @@
+import wandb
+from rsl_rl.utils import WandbLogWriter
+
+from mjlab.rl import RslRlVecEnvWrapper
+from mjlab.rl.exporter_utils import (
+  attach_metadata_to_onnx,
+  get_base_metadata,
+)
+from mjlab.rl.runner import MjlabOnPolicyRunner
+
+
+class VelocityOnPolicyRunner(MjlabOnPolicyRunner):
+  env: RslRlVecEnvWrapper
+
+  def save(self, path: str, infos=None):
+    super().save(path, infos)
+    policy_dir, filename, onnx_path = self._get_export_paths(path)
+    try:
+      self.export_policy_to_onnx(str(policy_dir), filename)
+      is_wandb = isinstance(self.logger.writer, WandbLogWriter)
+      run_name: str = wandb.run.name if is_wandb and wandb.run else "local"  # type: ignore[assignment]
+      metadata = get_base_metadata(self.env.unwrapped, run_name)
+      attach_metadata_to_onnx(str(onnx_path), metadata)
+      if is_wandb and self.cfg["upload_model"]:
+        wandb.save(str(onnx_path), base_path=str(policy_dir))
+    except Exception as e:
+      print(f"[WARN] ONNX export failed (training continues): {e}")
diff --git a/src/mjlab/tasks/velocity/velocity_env_cfg.py b/src/mjlab/tasks/velocity/velocity_env_cfg.py
new file mode 100644
index 0000000..0fbe217
--- /dev/null
+++ b/src/mjlab/tasks/velocity/velocity_env_cfg.py
@@ -0,0 +1,456 @@
+"""Velocity task configuration.
+
+This module provides a factory function to create a base velocity task config.
+Robot-specific configurations call the factory and customize as needed.
+"""
+
+import math
+from dataclasses import replace
+
+from mjlab.envs import ManagerBasedRlEnvCfg
+from mjlab.envs import mdp as envs_mdp
+from mjlab.envs.mdp import dr
+from mjlab.envs.mdp.actions import JointPositionActionCfg
+from mjlab.managers.action_manager import ActionTermCfg
+from mjlab.managers.command_manager import CommandTermCfg
+from mjlab.managers.curriculum_manager import CurriculumTermCfg
+from mjlab.managers.event_manager import EventTermCfg
+from mjlab.managers.metrics_manager import MetricsTermCfg
+from mjlab.managers.observation_manager import ObservationGroupCfg, ObservationTermCfg
+from mjlab.managers.reward_manager import RewardTermCfg
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.managers.termination_manager import TerminationTermCfg
+from mjlab.scene import SceneCfg
+from mjlab.sensor import (
+  GridPatternCfg,
+  ObjRef,
+  RayCastSensorCfg,
+  TerrainHeightSensorCfg,
+)
+from mjlab.sim import MujocoCfg, SimulationCfg
+from mjlab.tasks.velocity import mdp
+from mjlab.tasks.velocity.mdp import UniformVelocityCommandCfg
+from mjlab.terrains import TerrainEntityCfg
+from mjlab.terrains.config import ROUGH_TERRAINS_CFG
+from mjlab.utils.noise import UniformNoiseCfg as Unoise
+from mjlab.viewer import ViewerConfig
+
+
+def make_velocity_env_cfg() -> ManagerBasedRlEnvCfg:
+  """Create base velocity tracking task configuration."""
+
+  ##
+  # Sensors
+  ##
+
+  terrain_scan = RayCastSensorCfg(
+    name="terrain_scan",
+    frame=ObjRef(type="body", name="", entity="robot"),  # Set per-robot.
+    ray_alignment="yaw",
+    pattern=GridPatternCfg(size=(1.6, 1.0), resolution=0.1),
+    max_distance=5.0,
+    exclude_parent_body=True,
+    include_geom_groups=(0,),  # Terrain only.
+    debug_vis=True,
+  )
+
+  foot_height_scan = TerrainHeightSensorCfg(
+    name="foot_height_scan",
+    frame=(),  # Set per-robot: frame and pattern.
+    ray_alignment="yaw",
+    max_distance=1.0,
+    exclude_parent_body=True,
+    include_geom_groups=(0,),  # Terrain only.
+    debug_vis=True,
+    viz=TerrainHeightSensorCfg.VizCfg(
+      show_rays=True,
+      hit_color=(1.0, 0.0, 1.0, 0.8),  # Magenta rays.
+      hit_sphere_color=(1.0, 0.0, 1.0, 1.0),
+    ),
+  )
+
+  ##
+  # Observations
+  ##
+
+  actor_terms = {
+    "base_lin_vel": ObservationTermCfg(
+      func=mdp.builtin_sensor,
+      params={"sensor_name": "robot/imu_lin_vel"},
+      noise=Unoise(n_min=-0.5, n_max=0.5),
+    ),
+    "base_ang_vel": ObservationTermCfg(
+      func=mdp.builtin_sensor,
+      params={"sensor_name": "robot/imu_ang_vel"},
+      noise=Unoise(n_min=-0.2, n_max=0.2),
+    ),
+    "projected_gravity": ObservationTermCfg(
+      func=mdp.projected_gravity,
+      noise=Unoise(n_min=-0.05, n_max=0.05),
+    ),
+    "joint_pos": ObservationTermCfg(
+      func=mdp.joint_pos_rel,
+      params={"biased": True},
+      noise=Unoise(n_min=-0.01, n_max=0.01),
+    ),
+    "joint_vel": ObservationTermCfg(
+      func=mdp.joint_vel_rel,
+      noise=Unoise(n_min=-1.5, n_max=1.5),
+    ),
+    "actions": ObservationTermCfg(func=mdp.last_action),
+    "command": ObservationTermCfg(
+      func=mdp.generated_commands,
+      params={"command_name": "twist"},
+    ),
+    "height_scan": ObservationTermCfg(
+      func=envs_mdp.height_scan,
+      params={"sensor_name": "terrain_scan"},
+      noise=Unoise(n_min=-0.1, n_max=0.1),
+      scale=1 / terrain_scan.max_distance,
+    ),
+  }
+
+  critic_terms = {
+    **actor_terms,
+    # Critic sees the true (unbiased) joint positions as privileged information.
+    "joint_pos": ObservationTermCfg(func=mdp.joint_pos_rel),
+    "height_scan": ObservationTermCfg(
+      func=envs_mdp.height_scan,
+      params={"sensor_name": "terrain_scan"},
+      scale=1 / terrain_scan.max_distance,
+    ),
+    "foot_height": ObservationTermCfg(
+      func=mdp.foot_height,
+      params={"sensor_name": "foot_height_scan"},
+    ),
+    "foot_air_time": ObservationTermCfg(
+      func=mdp.foot_air_time,
+      params={"sensor_name": "feet_ground_contact"},
+    ),
+    "foot_contact": ObservationTermCfg(
+      func=mdp.foot_contact,
+      params={"sensor_name": "feet_ground_contact"},
+    ),
+    "foot_contact_forces": ObservationTermCfg(
+      func=mdp.foot_contact_forces,
+      params={"sensor_name": "feet_ground_contact"},
+    ),
+  }
+
+  observations = {
+    "actor": ObservationGroupCfg(
+      terms=actor_terms,
+      concatenate_terms=True,
+      enable_corruption=True,
+    ),
+    "critic": ObservationGroupCfg(
+      terms=critic_terms,
+      concatenate_terms=True,
+      enable_corruption=False,
+    ),
+  }
+
+  ##
+  # Metrics
+  ##
+
+  metrics = {
+    "mean_action_acc": MetricsTermCfg(
+      func=mdp.mean_action_acc,
+    ),
+  }
+
+  ##
+  # Actions
+  ##
+
+  actions: dict[str, ActionTermCfg] = {
+    "joint_pos": JointPositionActionCfg(
+      entity_name="robot",
+      actuator_names=(".*",),
+      scale=0.5,  # Override per-robot.
+      use_default_offset=True,
+    )
+  }
+
+  ##
+  # Commands
+  ##
+
+  commands: dict[str, CommandTermCfg] = {
+    "twist": UniformVelocityCommandCfg(
+      entity_name="robot",
+      resampling_time_range=(3.0, 8.0),
+      rel_standing_envs=0.1,
+      rel_heading_envs=0.3,
+      rel_forward_envs=0.2,
+      heading_command=True,
+      heading_control_stiffness=0.5,
+      debug_vis=True,
+      ranges=UniformVelocityCommandCfg.Ranges(
+        lin_vel_x=(-1.0, 1.0),
+        lin_vel_y=(-1.0, 1.0),
+        ang_vel_z=(-0.5, 0.5),
+        heading=(-math.pi, math.pi),
+      ),
+    )
+  }
+
+  ##
+  # Events
+  ##
+
+  events = {
+    "reset_base": EventTermCfg(
+      func=mdp.reset_root_state_uniform,
+      mode="reset",
+      params={
+        "pose_range": {
+          "x": (-0.5, 0.5),
+          "y": (-0.5, 0.5),
+          "z": (0.01, 0.05),
+          "yaw": (-3.14, 3.14),
+        },
+        "velocity_range": {},
+      },
+    ),
+    "reset_robot_joints": EventTermCfg(
+      func=mdp.reset_joints_by_offset,
+      mode="reset",
+      params={
+        "position_range": (0.0, 0.0),
+        "velocity_range": (0.0, 0.0),
+        "asset_cfg": SceneEntityCfg("robot", joint_names=(".*",)),
+      },
+    ),
+    "push_robot": EventTermCfg(
+      func=mdp.push_by_setting_velocity,
+      mode="interval",
+      interval_range_s=(1.0, 3.0),
+      params={
+        "velocity_range": {
+          "x": (-0.5, 0.5),
+          "y": (-0.5, 0.5),
+          "z": (-0.4, 0.4),
+          "roll": (-0.52, 0.52),
+          "pitch": (-0.52, 0.52),
+          "yaw": (-0.78, 0.78),
+        },
+      },
+    ),
+    "foot_friction": EventTermCfg(
+      mode="startup",
+      func=dr.geom_friction,
+      params={
+        "asset_cfg": SceneEntityCfg("robot", geom_names=()),  # Set per-robot.
+        "operation": "abs",
+        "ranges": (0.3, 1.2),
+        "shared_random": True,  # All foot geoms share the same friction.
+      },
+    ),
+    "encoder_bias": EventTermCfg(
+      mode="startup",
+      func=dr.encoder_bias,
+      params={
+        "asset_cfg": SceneEntityCfg("robot"),
+        "bias_range": (-0.015, 0.015),
+      },
+    ),
+    "base_com": EventTermCfg(
+      mode="startup",
+      func=dr.body_com_offset,
+      params={
+        "asset_cfg": SceneEntityCfg("robot", body_names=()),  # Set per-robot.
+        "operation": "add",
+        "ranges": {
+          0: (-0.025, 0.025),
+          1: (-0.025, 0.025),
+          2: (-0.03, 0.03),
+        },
+      },
+    ),
+  }
+
+  ##
+  # Rewards
+  ##
+
+  rewards = {
+    "track_linear_velocity": RewardTermCfg(
+      func=mdp.track_linear_velocity,
+      weight=2.0,
+      params={"command_name": "twist", "std": math.sqrt(0.25)},
+    ),
+    "track_angular_velocity": RewardTermCfg(
+      func=mdp.track_angular_velocity,
+      weight=2.0,
+      params={"command_name": "twist", "std": math.sqrt(0.5)},
+    ),
+    "upright": RewardTermCfg(
+      func=mdp.upright,
+      weight=1.0,
+      params={
+        "std": math.sqrt(0.2),
+        "asset_cfg": SceneEntityCfg("robot", body_names=()),  # Set per-robot.
+      },
+    ),
+    "pose": RewardTermCfg(
+      func=mdp.variable_posture,
+      weight=1.0,
+      params={
+        "asset_cfg": SceneEntityCfg("robot", joint_names=(".*",)),
+        "command_name": "twist",
+        "std_standing": {},  # Set per-robot.
+        "std_walking": {},  # Set per-robot.
+        "std_running": {},  # Set per-robot.
+        "walking_threshold": 0.05,
+        "running_threshold": 1.5,
+      },
+    ),
+    "body_ang_vel": RewardTermCfg(
+      func=mdp.body_angular_velocity_penalty,
+      weight=0.0,  # Override per-robot
+      params={"asset_cfg": SceneEntityCfg("robot", body_names=())},  # Set per-robot.
+    ),
+    "angular_momentum": RewardTermCfg(
+      func=mdp.angular_momentum_penalty,
+      weight=0.0,  # Override per-robot
+      params={"sensor_name": "robot/root_angmom"},
+    ),
+    "dof_pos_limits": RewardTermCfg(func=mdp.joint_pos_limits, weight=-1.0),
+    "action_rate_l2": RewardTermCfg(func=mdp.action_rate_l2, weight=-0.1),
+    "air_time": RewardTermCfg(
+      func=mdp.feet_air_time,
+      weight=0.0,  # Override per-robot.
+      params={
+        "sensor_name": "feet_ground_contact",
+        "threshold_min": 0.05,
+        "threshold_max": 0.5,
+        "command_name": "twist",
+        "command_threshold": 0.5,
+      },
+    ),
+    "foot_clearance": RewardTermCfg(
+      func=mdp.feet_clearance,
+      weight=-2.0,
+      params={
+        "target_height": 0.1,
+        "height_sensor_name": "foot_height_scan",
+        "command_name": "twist",
+        "command_threshold": 0.05,
+        "asset_cfg": SceneEntityCfg("robot", site_names=()),  # Set per-robot.
+      },
+    ),
+    "foot_swing_height": RewardTermCfg(
+      func=mdp.feet_swing_height,
+      weight=-0.25,
+      params={
+        "sensor_name": "feet_ground_contact",
+        "height_sensor_name": "foot_height_scan",
+        "target_height": 0.1,
+        "command_name": "twist",
+        "command_threshold": 0.05,
+      },
+    ),
+    "foot_slip": RewardTermCfg(
+      func=mdp.feet_slip,
+      weight=-0.1,
+      params={
+        "sensor_name": "feet_ground_contact",
+        "command_name": "twist",
+        "command_threshold": 0.05,
+        "asset_cfg": SceneEntityCfg("robot", site_names=()),  # Set per-robot.
+      },
+    ),
+    "soft_landing": RewardTermCfg(
+      func=mdp.soft_landing,
+      weight=-1e-5,
+      params={
+        "sensor_name": "feet_ground_contact",
+        "command_name": "twist",
+        "command_threshold": 0.05,
+      },
+    ),
+  }
+
+  ##
+  # Terminations
+  ##
+
+  terminations = {
+    "time_out": TerminationTermCfg(func=mdp.time_out, time_out=True),
+    "fell_over": TerminationTermCfg(
+      func=mdp.bad_orientation,
+      params={"limit_angle": math.radians(70.0)},
+    ),
+    "out_of_terrain_bounds": TerminationTermCfg(
+      func=mdp.out_of_terrain_bounds,
+      time_out=True,
+    ),
+  }
+
+  ##
+  # Curriculum
+  ##
+
+  curriculum = {
+    "terrain_levels": CurriculumTermCfg(
+      func=mdp.terrain_levels_vel,
+      params={"command_name": "twist"},
+    ),
+    "command_vel": CurriculumTermCfg(
+      func=mdp.commands_vel,
+      params={
+        "command_name": "twist",
+        "velocity_stages": [
+          {"step": 0, "lin_vel_x": (-1.0, 1.0), "ang_vel_z": (-0.5, 0.5)},
+          {"step": 5000 * 24, "lin_vel_x": (-1.5, 2.0), "ang_vel_z": (-0.7, 0.7)},
+          {"step": 10000 * 24, "lin_vel_x": (-2.0, 3.0)},
+        ],
+      },
+    ),
+  }
+
+  ##
+  # Assemble and return
+  ##
+
+  return ManagerBasedRlEnvCfg(
+    scene=SceneCfg(
+      terrain=TerrainEntityCfg(
+        terrain_type="generator",
+        terrain_generator=replace(ROUGH_TERRAINS_CFG),
+        max_init_terrain_level=5,
+      ),
+      sensors=(terrain_scan, foot_height_scan),
+      num_envs=1,
+      extent=2.0,
+    ),
+    observations=observations,
+    actions=actions,
+    commands=commands,
+    events=events,
+    rewards=rewards,
+    terminations=terminations,
+    curriculum=curriculum,
+    metrics=metrics,
+    viewer=ViewerConfig(
+      origin_type=ViewerConfig.OriginType.ASSET_BODY,
+      entity_name="robot",
+      body_name="",  # Set per-robot.
+      distance=3.0,
+      elevation=-5.0,
+      azimuth=90.0,
+    ),
+    sim=SimulationCfg(
+      nconmax=35,
+      njmax=1500,
+      mujoco=MujocoCfg(
+        timestep=0.005,
+        iterations=10,
+        ls_iterations=20,
+      ),
+    ),
+    decimation=4,
+    episode_length_s=20.0,
+  )
diff --git a/src/mjlab/terrains/README.md b/src/mjlab/terrains/README.md
new file mode 100644
index 0000000..bd7c828
--- /dev/null
+++ b/src/mjlab/terrains/README.md
@@ -0,0 +1,5 @@
+# Terrains
+
+Procedurally generate terrains using primitive geometries and heightfields.
+
+<img src="../../../docs/source/_static/content/rough_terrain.png" alt="Rough Terrain">
diff --git a/src/mjlab/terrains/__init__.py b/src/mjlab/terrains/__init__.py
new file mode 100644
index 0000000..883db2f
--- /dev/null
+++ b/src/mjlab/terrains/__init__.py
@@ -0,0 +1,52 @@
+from mjlab.terrains.heightfield_terrains import (
+  HfDiscreteObstaclesTerrainCfg as HfDiscreteObstaclesTerrainCfg,
+)
+from mjlab.terrains.heightfield_terrains import (
+  HfPerlinNoiseTerrainCfg as HfPerlinNoiseTerrainCfg,
+)
+from mjlab.terrains.heightfield_terrains import (
+  HfPyramidSlopedTerrainCfg as HfPyramidSlopedTerrainCfg,
+)
+from mjlab.terrains.heightfield_terrains import (
+  HfRandomUniformTerrainCfg as HfRandomUniformTerrainCfg,
+)
+from mjlab.terrains.heightfield_terrains import HfWaveTerrainCfg as HfWaveTerrainCfg
+from mjlab.terrains.primitive_terrains import BoxFlatTerrainCfg as BoxFlatTerrainCfg
+from mjlab.terrains.primitive_terrains import (
+  BoxInvertedPyramidStairsTerrainCfg as BoxInvertedPyramidStairsTerrainCfg,
+)
+from mjlab.terrains.primitive_terrains import (
+  BoxNarrowBeamsTerrainCfg as BoxNarrowBeamsTerrainCfg,
+)
+from mjlab.terrains.primitive_terrains import (
+  BoxNestedRingsTerrainCfg as BoxNestedRingsTerrainCfg,
+)
+from mjlab.terrains.primitive_terrains import (
+  BoxOpenStairsTerrainCfg as BoxOpenStairsTerrainCfg,
+)
+from mjlab.terrains.primitive_terrains import (
+  BoxPyramidStairsTerrainCfg as BoxPyramidStairsTerrainCfg,
+)
+from mjlab.terrains.primitive_terrains import (
+  BoxRandomGridTerrainCfg as BoxRandomGridTerrainCfg,
+)
+from mjlab.terrains.primitive_terrains import (
+  BoxRandomSpreadTerrainCfg as BoxRandomSpreadTerrainCfg,
+)
+from mjlab.terrains.primitive_terrains import (
+  BoxRandomStairsTerrainCfg as BoxRandomStairsTerrainCfg,
+)
+from mjlab.terrains.primitive_terrains import (
+  BoxSteppingStonesTerrainCfg as BoxSteppingStonesTerrainCfg,
+)
+from mjlab.terrains.primitive_terrains import (
+  BoxTiltedGridTerrainCfg as BoxTiltedGridTerrainCfg,
+)
+from mjlab.terrains.terrain_entity import TerrainEntity as TerrainEntity
+from mjlab.terrains.terrain_entity import TerrainEntityCfg as TerrainEntityCfg
+from mjlab.terrains.terrain_generator import (
+  FlatPatchSamplingCfg as FlatPatchSamplingCfg,
+)
+from mjlab.terrains.terrain_generator import SubTerrainCfg as SubTerrainCfg
+from mjlab.terrains.terrain_generator import TerrainGenerator as TerrainGenerator
+from mjlab.terrains.terrain_generator import TerrainGeneratorCfg as TerrainGeneratorCfg
diff --git a/src/mjlab/terrains/config.py b/src/mjlab/terrains/config.py
new file mode 100644
index 0000000..9ccd95c
--- /dev/null
+++ b/src/mjlab/terrains/config.py
@@ -0,0 +1,354 @@
+"""Terrain configuration presets and named terrain sets.
+
+Each terrain type has a preset function with sensible defaults. Override any
+parameter at the call site. Named configs (ROUGH, STAIRS, ALL) compose presets.
+
+To add a new terrain, define a function decorated with @terrain_preset::
+
+    @terrain_preset
+    def my_new_terrain(**overrides: Any) -> terrain_gen.SomeTerrainCfg:
+        defaults: dict[str, Any] = dict(...)
+        defaults.update(overrides)
+        return terrain_gen.SomeTerrainCfg(**defaults)
+
+It will be auto-included in ALL_TERRAIN_PRESETS and ALL_TERRAINS_CFG.
+"""
+
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+import mjlab.terrains as terrain_gen
+from mjlab.terrains.terrain_entity import TerrainEntity, TerrainEntityCfg
+from mjlab.terrains.terrain_generator import SubTerrainCfg, TerrainGeneratorCfg
+
+# Preset registry.
+
+ALL_TERRAIN_PRESETS: dict[str, Callable[..., SubTerrainCfg]] = {}
+
+_F = TypeVar("_F", bound=Callable[..., SubTerrainCfg])
+
+
+def terrain_preset(fn: _F) -> _F:
+  """Register a terrain preset into ALL_TERRAIN_PRESETS."""
+  ALL_TERRAIN_PRESETS[fn.__name__] = fn
+  return fn
+
+
+# Terrain presets.
+
+
+@terrain_preset
+def flat(**overrides: Any) -> terrain_gen.BoxFlatTerrainCfg:
+  return terrain_gen.BoxFlatTerrainCfg(**overrides)
+
+
+@terrain_preset
+def pyramid_stairs(**overrides: Any) -> terrain_gen.BoxPyramidStairsTerrainCfg:
+  defaults: dict[str, Any] = dict(
+    step_height_range=(0.0, 0.2),
+    step_width=0.3,
+    platform_width=3.0,
+    border_width=1.0,
+  )
+  defaults.update(overrides)
+  return terrain_gen.BoxPyramidStairsTerrainCfg(**defaults)
+
+
+@terrain_preset
+def pyramid_stairs_inv(
+  **overrides: Any,
+) -> terrain_gen.BoxInvertedPyramidStairsTerrainCfg:
+  defaults: dict[str, Any] = dict(
+    step_height_range=(0.0, 0.2),
+    step_width=0.3,
+    platform_width=3.0,
+    border_width=1.0,
+  )
+  defaults.update(overrides)
+  return terrain_gen.BoxInvertedPyramidStairsTerrainCfg(**defaults)
+
+
+@terrain_preset
+def hf_pyramid_slope(
+  **overrides: Any,
+) -> terrain_gen.HfPyramidSlopedTerrainCfg:
+  defaults: dict[str, Any] = dict(
+    slope_range=(0.0, 0.7),
+    platform_width=2.0,
+    border_width=0.25,
+  )
+  defaults.update(overrides)
+  return terrain_gen.HfPyramidSlopedTerrainCfg(**defaults)
+
+
+@terrain_preset
+def hf_pyramid_slope_inv(
+  **overrides: Any,
+) -> terrain_gen.HfPyramidSlopedTerrainCfg:
+  defaults: dict[str, Any] = dict(
+    slope_range=(0.0, 0.7),
+    platform_width=2.0,
+    border_width=0.25,
+    inverted=True,
+  )
+  defaults.update(overrides)
+  return terrain_gen.HfPyramidSlopedTerrainCfg(**defaults)
+
+
+@terrain_preset
+def random_rough(
+  **overrides: Any,
+) -> terrain_gen.HfRandomUniformTerrainCfg:
+  defaults: dict[str, Any] = dict(
+    noise_range=(0.02, 0.10),
+    noise_step=0.02,
+    border_width=0.25,
+  )
+  defaults.update(overrides)
+  return terrain_gen.HfRandomUniformTerrainCfg(**defaults)
+
+
+@terrain_preset
+def wave_terrain(**overrides: Any) -> terrain_gen.HfWaveTerrainCfg:
+  defaults: dict[str, Any] = dict(
+    amplitude_range=(0.0, 0.2),
+    num_waves=4,
+    border_width=0.25,
+  )
+  defaults.update(overrides)
+  return terrain_gen.HfWaveTerrainCfg(**defaults)
+
+
+@terrain_preset
+def discrete_obstacles(
+  **overrides: Any,
+) -> terrain_gen.HfDiscreteObstaclesTerrainCfg:
+  defaults: dict[str, Any] = dict(
+    obstacle_width_range=(0.3, 1.0),
+    obstacle_height_range=(0.05, 0.3),
+    num_obstacles=40,
+    border_width=0.25,
+  )
+  defaults.update(overrides)
+  return terrain_gen.HfDiscreteObstaclesTerrainCfg(**defaults)
+
+
+@terrain_preset
+def perlin_noise(
+  **overrides: Any,
+) -> terrain_gen.HfPerlinNoiseTerrainCfg:
+  defaults: dict[str, Any] = dict(
+    height_range=(0.0, 1.0),
+    octaves=4,
+    persistence=0.3,
+    lacunarity=2.0,
+    scale=10.0,
+    horizontal_scale=0.1,
+    border_width=0.50,
+  )
+  defaults.update(overrides)
+  return terrain_gen.HfPerlinNoiseTerrainCfg(**defaults)
+
+
+@terrain_preset
+def box_random_grid(
+  **overrides: Any,
+) -> terrain_gen.BoxRandomGridTerrainCfg:
+  defaults: dict[str, Any] = dict(
+    grid_width=0.4,
+    grid_height_range=(0.0, 0.3),
+    platform_width=1.0,
+  )
+  defaults.update(overrides)
+  return terrain_gen.BoxRandomGridTerrainCfg(**defaults)
+
+
+@terrain_preset
+def random_spread_boxes(
+  **overrides: Any,
+) -> terrain_gen.BoxRandomSpreadTerrainCfg:
+  defaults: dict[str, Any] = dict(
+    num_boxes=80,
+    box_width_range=(0.1, 1.0),
+    box_length_range=(0.1, 2.0),
+    box_height_range=(0.05, 0.3),
+    platform_width=1.0,
+    border_width=0.25,
+  )
+  defaults.update(overrides)
+  return terrain_gen.BoxRandomSpreadTerrainCfg(**defaults)
+
+
+@terrain_preset
+def open_stairs(
+  **overrides: Any,
+) -> terrain_gen.BoxOpenStairsTerrainCfg:
+  defaults: dict[str, Any] = dict(
+    step_height_range=(0.1, 0.2),
+    step_width_range=(0.4, 0.8),
+    platform_width=1.0,
+    border_width=0.25,
+    inverted=False,
+  )
+  defaults.update(overrides)
+  return terrain_gen.BoxOpenStairsTerrainCfg(**defaults)
+
+
+@terrain_preset
+def random_stairs(
+  **overrides: Any,
+) -> terrain_gen.BoxRandomStairsTerrainCfg:
+  defaults: dict[str, Any] = dict(
+    step_width=0.8,
+    step_height_range=(0.1, 0.3),
+    platform_width=1.0,
+    border_width=0.25,
+  )
+  defaults.update(overrides)
+  return terrain_gen.BoxRandomStairsTerrainCfg(**defaults)
+
+
+@terrain_preset
+def stepping_stones(
+  **overrides: Any,
+) -> terrain_gen.BoxSteppingStonesTerrainCfg:
+  defaults: dict[str, Any] = dict(
+    stone_size_range=(0.4, 0.8),
+    stone_distance_range=(0.2, 0.5),
+    stone_height=0.2,
+    stone_height_variation=0.1,
+    stone_size_variation=0.2,
+    displacement_range=0.1,
+    floor_depth=2.0,
+    platform_width=1.0,
+    border_width=0.25,
+  )
+  defaults.update(overrides)
+  return terrain_gen.BoxSteppingStonesTerrainCfg(**defaults)
+
+
+@terrain_preset
+def narrow_beams(
+  **overrides: Any,
+) -> terrain_gen.BoxNarrowBeamsTerrainCfg:
+  defaults: dict[str, Any] = dict(
+    num_beams=12,
+    beam_width_range=(0.2, 0.8),
+    beam_height=0.2,
+    spacing=0.8,
+    platform_width=1.0,
+    border_width=0.25,
+    floor_depth=2.0,
+  )
+  defaults.update(overrides)
+  return terrain_gen.BoxNarrowBeamsTerrainCfg(**defaults)
+
+
+@terrain_preset
+def nested_rings(
+  **overrides: Any,
+) -> terrain_gen.BoxNestedRingsTerrainCfg:
+  defaults: dict[str, Any] = dict(
+    num_rings=8,
+    ring_width_range=(0.3, 0.6),
+    gap_range=(0.1, 0.4),
+    height_range=(0.1, 0.4),
+    platform_width=1.0,
+    border_width=0.25,
+    floor_depth=2.0,
+  )
+  defaults.update(overrides)
+  return terrain_gen.BoxNestedRingsTerrainCfg(**defaults)
+
+
+@terrain_preset
+def tilted_grid(
+  **overrides: Any,
+) -> terrain_gen.BoxTiltedGridTerrainCfg:
+  defaults: dict[str, Any] = dict(
+    grid_width=1.0,
+    tilt_range_deg=20.0,
+    height_range=0.3,
+    platform_width=1.0,
+    border_width=0.25,
+    floor_depth=2.0,
+  )
+  defaults.update(overrides)
+  return terrain_gen.BoxTiltedGridTerrainCfg(**defaults)
+
+
+# Named terrain sets.
+
+ROUGH_TERRAINS_CFG = TerrainGeneratorCfg(
+  size=(8.0, 8.0),
+  border_width=20.0,
+  num_rows=10,
+  num_cols=20,
+  sub_terrains={
+    "flat": flat(proportion=0.2),
+    "pyramid_stairs": pyramid_stairs(proportion=0.2, step_height_range=(0.0, 0.1)),
+    "pyramid_stairs_inv": pyramid_stairs_inv(
+      proportion=0.2, step_height_range=(0.0, 0.1)
+    ),
+    "hf_pyramid_slope": hf_pyramid_slope(proportion=0.1, slope_range=(0.0, 1.0)),
+    "hf_pyramid_slope_inv": hf_pyramid_slope_inv(
+      proportion=0.1, slope_range=(0.0, 1.0)
+    ),
+    "random_rough": random_rough(proportion=0.1),
+    "wave_terrain": wave_terrain(proportion=0.1),
+  },
+  add_lights=True,
+)
+
+STAIRS_TERRAINS_CFG = TerrainGeneratorCfg(
+  size=(8.0, 8.0),
+  border_width=20.0,
+  num_rows=10,
+  num_cols=4,
+  curriculum=True,
+  sub_terrains={
+    "flat": flat(proportion=0.25),
+    "easy_stairs": pyramid_stairs(
+      proportion=0.35,
+      step_height_range=(0.02, 0.05),
+      step_width=0.40,
+    ),
+    "moderate_stairs": pyramid_stairs(
+      proportion=0.25,
+      step_height_range=(0.05, 0.08),
+      step_width=0.35,
+      platform_width=2.5,
+      border_width=0.8,
+    ),
+    "challenging_stairs": pyramid_stairs(
+      proportion=0.15,
+      step_height_range=(0.08, 0.10),
+      step_width=0.30,
+      platform_width=2.0,
+      border_width=0.5,
+    ),
+  },
+  add_lights=True,
+)
+
+ALL_TERRAINS_CFG = TerrainGeneratorCfg(
+  size=(8.0, 8.0),
+  border_width=20.0,
+  num_rows=10,
+  num_cols=len(ALL_TERRAIN_PRESETS),
+  sub_terrains={name: fn(proportion=1.0) for name, fn in ALL_TERRAIN_PRESETS.items()},
+  add_lights=True,
+)
+
+if __name__ == "__main__":
+  import mujoco.viewer
+  import torch
+
+  device = "cuda" if torch.cuda.is_available() else "cpu"
+
+  terrain_cfg = TerrainEntityCfg(
+    terrain_type="generator",
+    terrain_generator=ROUGH_TERRAINS_CFG,
+  )
+  terrain = TerrainEntity(terrain_cfg, device=device)
+  mujoco.viewer.launch(terrain.spec.compile())
diff --git a/src/mjlab/terrains/heightfield_terrains.py b/src/mjlab/terrains/heightfield_terrains.py
new file mode 100644
index 0000000..4c9b746
--- /dev/null
+++ b/src/mjlab/terrains/heightfield_terrains.py
@@ -0,0 +1,982 @@
+"""Terrains composed of heightfields.
+
+This module provides terrain generation functionality using heightfields,
+adapted from the IsaacLab terrain generation system.
+
+References:
+  IsaacLab mesh terrain implementation:
+  https://github.com/isaac-sim/IsaacLab/blob/main/source/isaaclab/isaaclab/terrains/height_field/hf_terrains.py
+"""
+
+import uuid
+from dataclasses import dataclass
+from typing import Literal
+
+import mujoco
+import numpy as np
+import scipy.interpolate as interpolate
+from scipy import ndimage
+
+from mjlab.terrains.terrain_generator import (
+  SubTerrainCfg,
+  TerrainGeometry,
+  TerrainOutput,
+)
+from mjlab.terrains.utils import find_flat_patches_from_heightfield
+
+# Smallest positive hfield elevation/base size, in meters. MuJoCo rejects
+# non-positive hfield sizes, so flat heightfields (difficulty 0) are clamped to
+# this instead of zero.
+_MIN_HFIELD_HEIGHT = 1e-3
+
+# Physical height (meters) that maps to full color saturation. Heights are
+# colored on this fixed absolute scale rather than normalized per patch, so a
+# given height reads the same color across every terrain and small-amplitude
+# terrain stays gently tinted instead of stretching into rainbow noise.
+_COLOR_SCALE = 0.75
+
+
+def color_by_height(
+  spec: mujoco.MjSpec,
+  noise: np.ndarray,
+  unique_id: str,
+  physical_heights: np.ndarray,
+  texture_size: int = 128,
+) -> str:
+  """Build a height-colored texture for a heightfield.
+
+  Diverging colormap anchored at the ground plane (z=0): cool blue below ground,
+  green at z=0, warm red above. ``physical_heights`` is the surface height of
+  each cell in meters relative to z=0; it is colored on the fixed ``_COLOR_SCALE``
+  so color encodes absolute height consistently across all terrains.
+  """
+  texture_name = f"hf_texture_{unique_id}"
+  texture = spec.add_texture(
+    name=texture_name,
+    type=mujoco.mjtTexture.mjTEXTURE_2D,
+    width=texture_size,
+    height=texture_size,
+  )
+
+  texture_height = ndimage.zoom(
+    physical_heights,
+    (texture_size / noise.shape[0], texture_size / noise.shape[1]),
+    order=1,
+  )
+  texture_height = np.asarray(texture_height)
+
+  # Signed deviation from the ground plane in [-1, 1] on a fixed absolute scale.
+  signed = np.clip(texture_height / _COLOR_SCALE, -1.0, 1.0)
+
+  # signed=+1 -> hue 0.0 (red, high), 0 -> 0.33 (green, ground), -1 -> 0.66 (blue, low).
+  hue = 0.33 - 0.33 * signed
+  saturation = 0.45 + 0.25 * np.abs(signed)
+  value = 0.45 + 0.25 * np.abs(signed)
+
+  c = value * saturation
+  x = c * (1 - np.abs((hue * 6) % 2 - 1))
+  m = value - c
+
+  hue_sector = (hue * 6).astype(int) % 6
+
+  r = np.zeros_like(hue)
+  g = np.zeros_like(hue)
+  b = np.zeros_like(hue)
+
+  mask = hue_sector == 0
+  r[mask] = c[mask]
+  g[mask] = x[mask]
+
+  mask = hue_sector == 1
+  r[mask] = x[mask]
+  g[mask] = c[mask]
+
+  mask = hue_sector == 2
+  g[mask] = c[mask]
+  b[mask] = x[mask]
+
+  mask = hue_sector == 3
+  g[mask] = x[mask]
+  b[mask] = c[mask]
+
+  mask = hue_sector == 4
+  r[mask] = x[mask]
+  b[mask] = c[mask]
+
+  mask = hue_sector == 5
+  r[mask] = c[mask]
+  b[mask] = x[mask]
+
+  r += m
+  g += m
+  b += m
+
+  rgb_data = np.stack([r, g, b], axis=-1)
+  rgb_data = (rgb_data * 255).astype(np.uint8)
+
+  rgb_data = np.flipud(rgb_data)
+  texture.data = rgb_data.tobytes()
+
+  material_name = f"hf_material_{unique_id}"
+  material = spec.add_material(name=material_name)
+  material.textures[mujoco.mjtTextureRole.mjTEXROLE_RGB] = texture_name
+
+  return material_name
+
+
+def _fractal_perlin_noise_2d(
+  x_size: int,
+  y_size: int,
+  rng: np.random.Generator,
+  octaves: int = 4,
+  persistence: float = 0.5,
+  lacunarity: float = 2.0,
+  scale: float = 1.0,
+) -> np.ndarray:
+  """Generate 2D fractal Perlin noise."""
+
+  def lerp(a, b, x):
+    return a + x * (b - a)
+
+  def fade(t):
+    return t * t * t * (t * (t * 6 - 15) + 10)
+
+  def gradient(h, x, y):
+    h = h % 4
+    return np.where(
+      h == 0,
+      x + y,
+      np.where(h == 1, x - y, np.where(h == 2, -x + y, -x - y)),
+    )
+
+  def perlin(x, y, p):
+    xi = x.astype(int) % 256
+    yi = y.astype(int) % 256
+    xf = x - x.astype(int)
+    yf = y - y.astype(int)
+    u = fade(xf)
+    v = fade(yf)
+
+    n00 = gradient(p[p[xi] + yi], xf, yf)
+    n01 = gradient(p[p[xi] + yi + 1], xf, yf - 1)
+    n11 = gradient(p[p[xi + 1] + yi + 1], xf - 1, yf - 1)
+    n10 = gradient(p[p[xi + 1] + yi], xf - 1, yf)
+
+    x1 = lerp(n00, n10, u)
+    x2 = lerp(n01, n11, u)
+    return lerp(x1, x2, v)
+
+  p = np.arange(256, dtype=int)
+  rng.shuffle(p)
+  p = np.stack([p, p]).flatten()
+
+  noise = np.zeros((x_size, y_size))
+  amplitude = 1.0
+  frequency = scale
+  total_amplitude = 0.0
+
+  x = np.linspace(0, x_size, x_size, endpoint=False)
+  y = np.linspace(0, y_size, y_size, endpoint=False)
+  xx, yy = np.meshgrid(x, y, indexing="ij")
+
+  for _ in range(octaves):
+    noise += amplitude * perlin(xx * frequency / x_size, yy * frequency / y_size, p)
+    total_amplitude += amplitude
+    amplitude *= persistence
+    frequency *= lacunarity
+
+  return noise / total_amplitude
+
+
+def _compute_flat_patches(
+  noise: np.ndarray,
+  vertical_scale: float,
+  horizontal_scale: float,
+  z_offset: float,
+  flat_patch_sampling: dict | None,
+  rng: np.random.Generator,
+) -> dict[str, np.ndarray] | None:
+  """Compute flat patches for a heightfield terrain if configured."""
+  if flat_patch_sampling is None:
+    return None
+  physical_heights = (noise.astype(np.float64) - noise.min()) * vertical_scale
+  flat_patches: dict[str, np.ndarray] = {}
+  for name, patch_cfg in flat_patch_sampling.items():
+    flat_patches[name] = find_flat_patches_from_heightfield(
+      heights=physical_heights,
+      horizontal_scale=horizontal_scale,
+      z_offset=z_offset,
+      cfg=patch_cfg,
+      rng=rng,
+    )
+  return flat_patches
+
+
+@dataclass(kw_only=True)
+class HfPyramidSlopedTerrainCfg(SubTerrainCfg):
+  slope_range: tuple[float, float]
+  """Range of slope gradients (rise / run), interpolated by difficulty."""
+  platform_width: float = 1.0
+  """Side length of the flat square platform at the terrain center, in meters."""
+  inverted: bool = False
+  """If True, the pyramid is inverted so the platform is at the bottom."""
+  border_width: float = 0.0
+  """Width of the flat border around the terrain edges, in meters. Must be >=
+  horizontal_scale if non-zero."""
+  horizontal_scale: float = 0.1
+  """Heightfield grid resolution along x and y, in meters per cell."""
+  vertical_scale: float = 0.005
+  """Heightfield height resolution, in meters per integer unit of the noise array."""
+  base_thickness_ratio: float = 1.0
+  """Ratio of the heightfield base thickness to its maximum surface height."""
+
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    body = spec.body("terrain")
+
+    if self.inverted:
+      slope = -self.slope_range[0] - difficulty * (
+        self.slope_range[1] - self.slope_range[0]
+      )
+    else:
+      slope = self.slope_range[0] + difficulty * (
+        self.slope_range[1] - self.slope_range[0]
+      )
+
+    if self.border_width > 0 and self.border_width < self.horizontal_scale:
+      raise ValueError(
+        f"Border width ({self.border_width}) must be >= horizontal scale "
+        f"({self.horizontal_scale})"
+      )
+
+    border_pixels = int(self.border_width / self.horizontal_scale)
+    width_pixels = int(self.size[0] / self.horizontal_scale)
+    length_pixels = int(self.size[1] / self.horizontal_scale)
+
+    inner_width_pixels = width_pixels - 2 * border_pixels
+    inner_length_pixels = length_pixels - 2 * border_pixels
+
+    noise = np.zeros((width_pixels, length_pixels), dtype=np.int16)
+
+    if border_pixels > 0:
+      height_max = int(
+        slope * (inner_width_pixels * self.horizontal_scale) / 2 / self.vertical_scale
+      )
+
+      center_x = int(inner_width_pixels / 2)
+      center_y = int(inner_length_pixels / 2)
+
+      x = np.arange(0, inner_width_pixels)
+      y = np.arange(0, inner_length_pixels)
+      xx, yy = np.meshgrid(x, y, sparse=True)
+
+      xx = (center_x - np.abs(center_x - xx)) / center_x
+      yy = (center_y - np.abs(center_y - yy)) / center_y
+
+      xx = xx.reshape(inner_width_pixels, 1)
+      yy = yy.reshape(1, inner_length_pixels)
+
+      hf_raw = height_max * xx * yy
+
+      platform_width = int(self.platform_width / self.horizontal_scale / 2)
+      x_pf = inner_width_pixels // 2 - platform_width
+      y_pf = inner_length_pixels // 2 - platform_width
+      z_pf = hf_raw[x_pf, y_pf] if x_pf >= 0 and y_pf >= 0 else 0
+      hf_raw = np.clip(hf_raw, min(0, z_pf), max(0, z_pf))
+
+      noise[
+        border_pixels : -border_pixels if border_pixels else width_pixels,
+        border_pixels : -border_pixels if border_pixels else length_pixels,
+      ] = np.rint(hf_raw).astype(np.int16)
+    else:
+      height_max = int(slope * self.size[0] / 2 / self.vertical_scale)
+
+      center_x = int(width_pixels / 2)
+      center_y = int(length_pixels / 2)
+
+      x = np.arange(0, width_pixels)
+      y = np.arange(0, length_pixels)
+      xx, yy = np.meshgrid(x, y, sparse=True)
+
+      xx = (center_x - np.abs(center_x - xx)) / center_x
+      yy = (center_y - np.abs(center_y - yy)) / center_y
+
+      xx = xx.reshape(width_pixels, 1)
+      yy = yy.reshape(1, length_pixels)
+
+      hf_raw = height_max * xx * yy
+
+      platform_width = int(self.platform_width / self.horizontal_scale / 2)
+      x_pf = width_pixels // 2 - platform_width
+      y_pf = length_pixels // 2 - platform_width
+      z_pf = hf_raw[x_pf, y_pf]
+      hf_raw = np.clip(hf_raw, min(0, z_pf), max(0, z_pf))
+
+      noise = np.rint(hf_raw).astype(np.int16)
+
+    elevation_min = np.min(noise)
+    elevation_max = np.max(noise)
+    elevation_range = (
+      elevation_max - elevation_min if elevation_max != elevation_min else 1
+    )
+
+    max_physical_height = elevation_range * self.vertical_scale
+    base_thickness = max_physical_height * self.base_thickness_ratio
+
+    if elevation_range > 0:
+      normalized_elevation = (noise - elevation_min) / elevation_range
+    else:
+      normalized_elevation = np.zeros_like(noise)
+
+    unique_id = uuid.uuid4().hex
+    field = spec.add_hfield(
+      name=f"hfield_{unique_id}",
+      size=[
+        self.size[0] / 2,
+        self.size[1] / 2,
+        max_physical_height,
+        base_thickness,
+      ],
+      nrow=noise.shape[0],
+      ncol=noise.shape[1],
+      userdata=normalized_elevation.flatten().astype(np.float32).tolist(),
+    )
+
+    if self.inverted:
+      hfield_z_offset = -max_physical_height
+    else:
+      hfield_z_offset = 0
+
+    physical_heights = hfield_z_offset + normalized_elevation * max_physical_height
+    material_name = color_by_height(spec, noise, unique_id, physical_heights)
+
+    hfield_geom = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_HFIELD,
+      hfieldname=field.name,
+      pos=[
+        self.size[0] / 2,
+        self.size[1] / 2,
+        hfield_z_offset,
+      ],
+      material=material_name,
+    )
+
+    if self.inverted:
+      spawn_height = hfield_z_offset
+    else:
+      spawn_height = max_physical_height
+
+    origin = np.array([self.size[0] / 2, self.size[1] / 2, spawn_height])
+
+    flat_patches = _compute_flat_patches(
+      noise,
+      self.vertical_scale,
+      self.horizontal_scale,
+      hfield_z_offset,
+      self.flat_patch_sampling,
+      rng,
+    )
+
+    geom = TerrainGeometry(geom=hfield_geom, hfield=field)
+    return TerrainOutput(origin=origin, geometries=[geom], flat_patches=flat_patches)
+
+
+@dataclass(kw_only=True)
+class HfRandomUniformTerrainCfg(SubTerrainCfg):
+  noise_range: tuple[float, float]
+  """Min and max height noise, in meters."""
+  noise_step: float = 0.005
+  """Height quantization step, in meters. Sampled heights are multiples of this
+  value within noise_range."""
+  downsampled_scale: float | None = None
+  """Spacing between randomly sampled height points before interpolation, in
+  meters. If None, uses horizontal_scale. Must be >= horizontal_scale."""
+  horizontal_scale: float = 0.1
+  """Heightfield grid resolution along x and y, in meters per cell."""
+  vertical_scale: float = 0.005
+  """Heightfield height resolution, in meters per integer unit of the noise array."""
+  base_thickness_ratio: float = 1.0
+  """Ratio of the heightfield base thickness to its maximum surface height."""
+  border_width: float = 0.0
+  """Width of the flat border around the terrain edges, in meters. Must be >=
+  horizontal_scale if non-zero."""
+  scale_with_difficulty: bool = False
+  """If False (default), the roughness is fixed and ``difficulty`` is ignored,
+  matching upstream behavior. If True, the noise amplitude scales linearly with
+  difficulty (flat at 0, full ``noise_range`` at 1) so the terrain progresses in
+  a curriculum."""
+
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    body = spec.body("terrain")
+
+    # When difficulty scaling is enabled, ramp the noise amplitude from flat (0)
+    # to the full configured range (1). Otherwise use the full range regardless
+    # of difficulty (difficulty is ignored).
+    scale = difficulty if self.scale_with_difficulty else 1.0
+    noise_lo = self.noise_range[0] * scale
+    noise_hi = self.noise_range[1] * scale
+
+    if self.border_width > 0 and self.border_width < self.horizontal_scale:
+      raise ValueError(
+        f"Border width ({self.border_width}) must be >= horizontal scale "
+        f"({self.horizontal_scale})"
+      )
+
+    if self.downsampled_scale is None:
+      downsampled_scale = self.horizontal_scale
+    elif self.downsampled_scale < self.horizontal_scale:
+      raise ValueError(
+        f"Downsampled scale must be >= horizontal scale: "
+        f"{self.downsampled_scale} < {self.horizontal_scale}"
+      )
+    else:
+      downsampled_scale = self.downsampled_scale
+
+    border_pixels = int(self.border_width / self.horizontal_scale)
+    width_pixels = int(self.size[0] / self.horizontal_scale)
+    length_pixels = int(self.size[1] / self.horizontal_scale)
+
+    noise = np.zeros((width_pixels, length_pixels), dtype=np.int16)
+
+    if border_pixels > 0:
+      inner_width_pixels = width_pixels - 2 * border_pixels
+      inner_length_pixels = length_pixels - 2 * border_pixels
+      inner_size = (
+        inner_width_pixels * self.horizontal_scale,
+        inner_length_pixels * self.horizontal_scale,
+      )
+
+      width_downsampled = int(inner_size[0] / downsampled_scale)
+      length_downsampled = int(inner_size[1] / downsampled_scale)
+
+      height_min = int(noise_lo / self.vertical_scale)
+      height_max = int(noise_hi / self.vertical_scale)
+      height_step = int(self.noise_step / self.vertical_scale)
+
+      height_range = np.arange(height_min, height_max + height_step, height_step)
+      height_field_downsampled = rng.choice(
+        height_range, size=(width_downsampled, length_downsampled)
+      )
+
+      x = np.linspace(0, inner_size[0], width_downsampled)
+      y = np.linspace(0, inner_size[1], length_downsampled)
+      func = interpolate.RectBivariateSpline(x, y, height_field_downsampled)
+
+      x_upsampled = np.linspace(0, inner_size[0], inner_width_pixels)
+      y_upsampled = np.linspace(0, inner_size[1], inner_length_pixels)
+      z_upsampled = func(x_upsampled, y_upsampled)
+
+      noise[
+        border_pixels : -border_pixels if border_pixels else width_pixels,
+        border_pixels : -border_pixels if border_pixels else length_pixels,
+      ] = np.rint(z_upsampled).astype(np.int16)
+    else:
+      width_downsampled = int(self.size[0] / downsampled_scale)
+      length_downsampled = int(self.size[1] / downsampled_scale)
+      height_min = int(noise_lo / self.vertical_scale)
+      height_max = int(noise_hi / self.vertical_scale)
+      height_step = int(self.noise_step / self.vertical_scale)
+
+      height_range = np.arange(height_min, height_max + height_step, height_step)
+      height_field_downsampled = rng.choice(
+        height_range, size=(width_downsampled, length_downsampled)
+      )
+
+      x = np.linspace(0, self.size[0], width_downsampled)
+      y = np.linspace(0, self.size[1], length_downsampled)
+      func = interpolate.RectBivariateSpline(x, y, height_field_downsampled)
+
+      x_upsampled = np.linspace(0, self.size[0], width_pixels)
+      y_upsampled = np.linspace(0, self.size[1], length_pixels)
+      z_upsampled = func(x_upsampled, y_upsampled)
+      noise = np.rint(z_upsampled).astype(np.int16)
+
+    elevation_min = np.min(noise)
+    elevation_max = np.max(noise)
+    elevation_range = (
+      elevation_max - elevation_min if elevation_max != elevation_min else 1
+    )
+
+    max_physical_height = elevation_range * self.vertical_scale
+    base_thickness = max_physical_height * self.base_thickness_ratio
+
+    if elevation_range > 0:
+      normalized_elevation = (noise - elevation_min) / elevation_range
+    else:
+      normalized_elevation = np.zeros_like(noise)
+
+    unique_id = uuid.uuid4().hex
+    field = spec.add_hfield(
+      name=f"hfield_{unique_id}",
+      size=[
+        self.size[0] / 2,
+        self.size[1] / 2,
+        max_physical_height,
+        base_thickness,
+      ],
+      nrow=noise.shape[0],
+      ncol=noise.shape[1],
+      userdata=normalized_elevation.flatten().astype(np.float32).tolist(),
+    )
+
+    physical_heights = normalized_elevation * max_physical_height
+    material_name = color_by_height(spec, noise, unique_id, physical_heights)
+
+    hfield_geom = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_HFIELD,
+      hfieldname=field.name,
+      pos=[self.size[0] / 2, self.size[1] / 2, 0],
+      material=material_name,
+    )
+
+    spawn_height = (noise_lo + noise_hi) / 2
+    origin = np.array([self.size[0] / 2, self.size[1] / 2, spawn_height])
+
+    flat_patches = _compute_flat_patches(
+      noise,
+      self.vertical_scale,
+      self.horizontal_scale,
+      0,
+      self.flat_patch_sampling,
+      rng,
+    )
+
+    geom = TerrainGeometry(geom=hfield_geom, hfield=field)
+    return TerrainOutput(origin=origin, geometries=[geom], flat_patches=flat_patches)
+
+
+@dataclass(kw_only=True)
+class HfWaveTerrainCfg(SubTerrainCfg):
+  amplitude_range: tuple[float, float]
+  """Min and max wave amplitude, in meters. Interpolated by difficulty."""
+  num_waves: int = 1
+  """Number of complete wave cycles along the terrain length."""
+  horizontal_scale: float = 0.1
+  """Heightfield grid resolution along x and y, in meters per cell."""
+  vertical_scale: float = 0.005
+  """Heightfield height resolution, in meters per integer unit of the noise array."""
+  base_thickness_ratio: float = 0.25
+  """Ratio of the heightfield base thickness to its maximum surface height."""
+  border_width: float = 0.0
+  """Width of the flat border around the terrain edges, in meters. Must be >=
+  horizontal_scale if non-zero."""
+
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    body = spec.body("terrain")
+
+    if self.num_waves <= 0:
+      raise ValueError(f"Number of waves must be positive. Got: {self.num_waves}")
+
+    if self.border_width > 0 and self.border_width < self.horizontal_scale:
+      raise ValueError(
+        f"Border width ({self.border_width}) must be >= horizontal scale "
+        f"({self.horizontal_scale})"
+      )
+
+    amplitude = self.amplitude_range[0] + difficulty * (
+      self.amplitude_range[1] - self.amplitude_range[0]
+    )
+
+    border_pixels = int(self.border_width / self.horizontal_scale)
+    width_pixels = int(self.size[0] / self.horizontal_scale)
+    length_pixels = int(self.size[1] / self.horizontal_scale)
+
+    noise = np.zeros((width_pixels, length_pixels), dtype=np.int16)
+
+    if border_pixels > 0:
+      inner_width_pixels = width_pixels - 2 * border_pixels
+      inner_length_pixels = length_pixels - 2 * border_pixels
+
+      amplitude_pixels = int(0.5 * amplitude / self.vertical_scale)
+      wave_length = inner_length_pixels / self.num_waves
+      wave_number = 2 * np.pi / wave_length
+
+      x = np.arange(0, inner_width_pixels)
+      y = np.arange(0, inner_length_pixels)
+      xx, yy = np.meshgrid(x, y, sparse=True)
+      xx = xx.reshape(inner_width_pixels, 1)
+      yy = yy.reshape(1, inner_length_pixels)
+
+      hf_raw = amplitude_pixels * (np.cos(yy * wave_number) + np.sin(xx * wave_number))
+
+      noise[
+        border_pixels : -border_pixels if border_pixels else width_pixels,
+        border_pixels : -border_pixels if border_pixels else length_pixels,
+      ] = np.rint(hf_raw).astype(np.int16)
+    else:
+      amplitude_pixels = int(0.5 * amplitude / self.vertical_scale)
+      wave_length = length_pixels / self.num_waves
+      wave_number = 2 * np.pi / wave_length
+
+      x = np.arange(0, width_pixels)
+      y = np.arange(0, length_pixels)
+      xx, yy = np.meshgrid(x, y, sparse=True)
+      xx = xx.reshape(width_pixels, 1)
+      yy = yy.reshape(1, length_pixels)
+
+      hf_raw = amplitude_pixels * (np.cos(yy * wave_number) + np.sin(xx * wave_number))
+      noise = np.rint(hf_raw).astype(np.int16)
+
+    elevation_min = np.min(noise)
+    elevation_max = np.max(noise)
+    elevation_range = (
+      elevation_max - elevation_min if elevation_max != elevation_min else 1
+    )
+
+    max_physical_height = elevation_range * self.vertical_scale
+    base_thickness = max_physical_height * self.base_thickness_ratio
+
+    if elevation_range > 0:
+      normalized_elevation = (noise - elevation_min) / elevation_range
+    else:
+      normalized_elevation = np.zeros_like(noise)
+
+    unique_id = uuid.uuid4().hex
+    field = spec.add_hfield(
+      name=f"hfield_{unique_id}",
+      size=[
+        self.size[0] / 2,
+        self.size[1] / 2,
+        max_physical_height,
+        base_thickness,
+      ],
+      nrow=noise.shape[0],
+      ncol=noise.shape[1],
+      userdata=normalized_elevation.flatten().astype(np.float32).tolist(),
+    )
+
+    # The wave oscillates around z=0 (geom is offset down by half the range).
+    physical_heights = (
+      normalized_elevation * max_physical_height - max_physical_height / 2
+    )
+    material_name = color_by_height(spec, noise, unique_id, physical_heights)
+
+    hfield_geom = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_HFIELD,
+      hfieldname=field.name,
+      pos=[self.size[0] / 2, self.size[1] / 2, -max_physical_height / 2],
+      material=material_name,
+    )
+
+    spawn_height = 0.0
+    origin = np.array([self.size[0] / 2, self.size[1] / 2, spawn_height])
+
+    flat_patches = _compute_flat_patches(
+      noise,
+      self.vertical_scale,
+      self.horizontal_scale,
+      -max_physical_height / 2,
+      self.flat_patch_sampling,
+      rng,
+    )
+
+    geom = TerrainGeometry(geom=hfield_geom, hfield=field)
+    return TerrainOutput(origin=origin, geometries=[geom], flat_patches=flat_patches)
+
+
+@dataclass(kw_only=True)
+class HfDiscreteObstaclesTerrainCfg(SubTerrainCfg):
+  obstacle_height_mode: Literal["choice", "fixed"] = "choice"
+  """How obstacle heights are chosen. "choice" randomly picks from [-h, -h/2,
+  h/2, h] (mix of pits and bumps); "fixed" uses h for all obstacles."""
+  obstacle_width_range: tuple[float, float]
+  """Min and max obstacle width, in meters."""
+  obstacle_height_range: tuple[float, float]
+  """Min and max obstacle height, in meters. Interpolated by difficulty."""
+  num_obstacles: int
+  """Number of obstacles to place on the terrain."""
+  platform_width: float = 1.0
+  """Side length of the obstacle-free flat square at the terrain center, in meters."""
+  horizontal_scale: float = 0.1
+  """Heightfield grid resolution along x and y, in meters per cell."""
+  vertical_scale: float = 0.005
+  """Heightfield height resolution, in meters per integer unit of the noise array."""
+  base_thickness_ratio: float = 1.0
+  """Ratio of the heightfield base thickness to its maximum surface height."""
+  border_width: float = 0.0
+  """Width of the flat border around the terrain edges, in meters. Must be >=
+  horizontal_scale if non-zero."""
+  square_obstacles: bool = False
+  """If True, obstacles have equal width and length. If False, each dimension
+  is sampled independently."""
+  origin_z_offset: float = 0.0
+  """Vertical offset added to spawn origin height (meters).
+
+  Useful to prevent robot feet from clipping through terrain when spawning at
+  the origin.
+  """
+
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    body = spec.body("terrain")
+
+    if self.border_width > 0 and self.border_width < self.horizontal_scale:
+      raise ValueError(
+        f"Border width ({self.border_width}) must be >= horizontal scale "
+        f"({self.horizontal_scale})"
+      )
+
+    obs_height = self.obstacle_height_range[0] + difficulty * (
+      self.obstacle_height_range[1] - self.obstacle_height_range[0]
+    )
+
+    border_pixels = int(self.border_width / self.horizontal_scale)
+    width_pixels = int(self.size[0] / self.horizontal_scale)
+    length_pixels = int(self.size[1] / self.horizontal_scale)
+
+    obs_h = int(obs_height / self.vertical_scale)
+    obs_width_min = int(self.obstacle_width_range[0] / self.horizontal_scale)
+    obs_width_max = int(self.obstacle_width_range[1] / self.horizontal_scale)
+    platform_pixels = int(self.platform_width / self.horizontal_scale)
+
+    if border_pixels > 0:
+      inner_width_pixels = width_pixels - 2 * border_pixels
+      inner_length_pixels = length_pixels - 2 * border_pixels
+    else:
+      inner_width_pixels = width_pixels
+      inner_length_pixels = length_pixels
+
+    noise = np.zeros((inner_width_pixels, inner_length_pixels), dtype=np.int16)
+
+    obs_width_range = np.arange(obs_width_min, obs_width_max + 1, 4)
+    if len(obs_width_range) == 0:
+      obs_width_range = np.array([obs_width_min])
+
+    for _ in range(self.num_obstacles):
+      if self.obstacle_height_mode == "choice":
+        h = rng.choice(np.array([-obs_h, -obs_h // 2, obs_h // 2, obs_h]))
+      else:
+        h = obs_h
+
+      w = rng.choice(obs_width_range)
+      obs_len = w if self.square_obstacles else rng.choice(obs_width_range)
+
+      x_range = np.arange(0, inner_width_pixels, 4)
+      y_range = np.arange(0, inner_length_pixels, 4)
+      if len(x_range) == 0 or len(y_range) == 0:
+        continue
+      x = rng.choice(x_range)
+      y = rng.choice(y_range)
+
+      x_end = min(x + w, inner_width_pixels)
+      y_end = min(y + obs_len, inner_length_pixels)
+      noise[x:x_end, y:y_end] = h
+
+    # Clear center platform.
+    cx = inner_width_pixels // 2
+    cy = inner_length_pixels // 2
+    half_pf = platform_pixels // 2
+    x0 = max(cx - half_pf, 0)
+    x1 = min(cx + half_pf, inner_width_pixels)
+    y0 = max(cy - half_pf, 0)
+    y1 = min(cy + half_pf, inner_length_pixels)
+    noise[x0:x1, y0:y1] = 0
+
+    if border_pixels > 0:
+      outer_noise = np.zeros((width_pixels, length_pixels), dtype=np.int16)
+      outer_noise[
+        border_pixels : border_pixels + inner_width_pixels,
+        border_pixels : border_pixels + inner_length_pixels,
+      ] = noise
+      noise = outer_noise
+
+    elevation_min = np.min(noise)
+    elevation_max = np.max(noise)
+    elevation_range = (
+      elevation_max - elevation_min if elevation_max != elevation_min else 1
+    )
+
+    max_physical_height = elevation_range * self.vertical_scale
+    base_thickness = max_physical_height * self.base_thickness_ratio
+
+    if elevation_range > 0:
+      normalized_elevation = (noise - elevation_min) / elevation_range
+    else:
+      normalized_elevation = np.zeros_like(noise)
+
+    unique_id = uuid.uuid4().hex
+    field = spec.add_hfield(
+      name=f"hfield_{unique_id}",
+      size=[
+        self.size[0] / 2,
+        self.size[1] / 2,
+        max_physical_height,
+        base_thickness,
+      ],
+      nrow=noise.shape[0],
+      ncol=noise.shape[1],
+      userdata=normalized_elevation.flatten().astype(np.float32).tolist(),
+    )
+
+    # For "choice" mode, obstacles can be negative (pits), so offset the
+    # geom down so that the zero-level of the noise aligns with z=0.
+    if self.obstacle_height_mode == "choice":
+      hfield_z_offset = elevation_min * self.vertical_scale
+    else:
+      hfield_z_offset = 0
+
+    # Physical surface height per cell (pits negative, bumps positive about z=0).
+    physical_heights = hfield_z_offset + normalized_elevation * max_physical_height
+    material_name = color_by_height(spec, noise, unique_id, physical_heights)
+
+    hfield_geom = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_HFIELD,
+      hfieldname=field.name,
+      pos=[
+        self.size[0] / 2,
+        self.size[1] / 2,
+        hfield_z_offset,
+      ],
+      material=material_name,
+    )
+
+    # The cleared platform (noise=0) is at z=0 due to the offset logic.
+    spawn_height = self.origin_z_offset
+    origin = np.array([self.size[0] / 2, self.size[1] / 2, spawn_height])
+
+    flat_patches = _compute_flat_patches(
+      noise,
+      self.vertical_scale,
+      self.horizontal_scale,
+      hfield_z_offset,
+      self.flat_patch_sampling,
+      rng,
+    )
+
+    geom = TerrainGeometry(geom=hfield_geom, hfield=field)
+    return TerrainOutput(origin=origin, geometries=[geom], flat_patches=flat_patches)
+
+
+@dataclass(kw_only=True)
+class HfPerlinNoiseTerrainCfg(SubTerrainCfg):
+  height_range: tuple[float, float]
+  octaves: int = 4
+  persistence: float = 0.5
+  lacunarity: float = 2.0
+  scale: float = 10.0
+  horizontal_scale: float = 0.1
+  resolution: float = 0.05
+  base_thickness_ratio: float = 1.0
+  border_width: float = 0.0
+
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    body = spec.body("terrain")
+
+    if self.border_width > 0 and self.border_width < self.horizontal_scale:
+      raise ValueError(
+        f"Border width ({self.border_width}) must be >= "
+        f"horizontal_scale ({self.horizontal_scale})"
+      )
+
+    target_height = self.height_range[0] + difficulty * (
+      self.height_range[1] - self.height_range[0]
+    )
+
+    # Resolution is the pixel size (distance between grid points).
+    grid_spacing = self.resolution
+
+    # Feature scale is affected by both 'scale' and 'horizontal_scale'.
+    # A larger horizontal_scale means larger features (stretched out).
+    effective_scale = self.scale * (self.resolution / self.horizontal_scale)
+
+    border_pixels = int(self.border_width / grid_spacing)
+    width_pixels = int(self.size[0] / grid_spacing)
+    length_pixels = int(self.size[1] / grid_spacing)
+
+    if border_pixels > 0:
+      inner_width_pixels = width_pixels - 2 * border_pixels
+      inner_length_pixels = length_pixels - 2 * border_pixels
+      noise_raw = _fractal_perlin_noise_2d(
+        inner_width_pixels,
+        inner_length_pixels,
+        rng,
+        octaves=self.octaves,
+        persistence=self.persistence,
+        lacunarity=self.lacunarity,
+        scale=effective_scale,
+      )
+      # Normalize to [0, 1]
+      noise_min, noise_max = noise_raw.min(), noise_raw.max()
+      noise_range = noise_max - noise_min if noise_max > noise_min else 1.0
+      inner_normalized = (noise_raw - noise_min) / noise_range
+
+      normalized_elevation = np.zeros((width_pixels, length_pixels), dtype=np.float32)
+      normalized_elevation[
+        border_pixels:-border_pixels,
+        border_pixels:-border_pixels,
+      ] = inner_normalized
+    else:
+      noise_raw = _fractal_perlin_noise_2d(
+        width_pixels,
+        length_pixels,
+        rng,
+        octaves=self.octaves,
+        persistence=self.persistence,
+        lacunarity=self.lacunarity,
+        scale=effective_scale,
+      )
+      noise_min, noise_max = noise_raw.min(), noise_raw.max()
+      noise_range = noise_max - noise_min if noise_max > noise_min else 1.0
+      normalized_elevation = ((noise_raw - noise_min) / noise_range).astype(np.float32)
+
+    # MuJoCo requires positive hfield elevation and base sizes. At difficulty 0
+    # (target_height == 0) the surface is flat; clamp to a small positive height
+    # so compilation does not fail with "size parameter is not positive".
+    max_physical_height = max(target_height, _MIN_HFIELD_HEIGHT)
+    base_thickness = max(
+      max_physical_height * self.base_thickness_ratio, _MIN_HFIELD_HEIGHT
+    )
+
+    unique_id = uuid.uuid4().hex
+    field = spec.add_hfield(
+      name=f"hfield_{unique_id}",
+      size=[
+        self.size[0] / 2,
+        self.size[1] / 2,
+        max_physical_height,
+        base_thickness,
+      ],
+      nrow=normalized_elevation.shape[0],
+      ncol=normalized_elevation.shape[1],
+      userdata=normalized_elevation.flatten().tolist(),
+    )
+
+    physical_heights = normalized_elevation * max_physical_height
+    material_name = color_by_height(
+      spec, normalized_elevation, unique_id, physical_heights
+    )
+
+    hfield_geom = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_HFIELD,
+      hfieldname=field.name,
+      pos=[
+        self.size[0] / 2,
+        self.size[1] / 2,
+        0,
+      ],
+      material=material_name,
+    )
+
+    spawn_height = max_physical_height
+    origin = np.array([self.size[0] / 2, self.size[1] / 2, spawn_height])
+
+    # For flat patches, we pass the absolute physical heights.
+    flat_patches = _compute_flat_patches(
+      normalized_elevation * max_physical_height,
+      1.0,  # vertical_scale is 1.0 because we already have physical heights
+      grid_spacing,
+      0,
+      self.flat_patch_sampling,
+      rng,
+    )
+
+    geom = TerrainGeometry(geom=hfield_geom, hfield=field)
+    return TerrainOutput(origin=origin, geometries=[geom], flat_patches=flat_patches)
diff --git a/src/mjlab/terrains/primitive_terrains.py b/src/mjlab/terrains/primitive_terrains.py
new file mode 100644
index 0000000..3a2d08a
--- /dev/null
+++ b/src/mjlab/terrains/primitive_terrains.py
@@ -0,0 +1,1760 @@
+"""Terrains composed of primitive geometries.
+
+This module provides terrain generation functionality using primitive geometries,
+adapted from the IsaacLab terrain generation system.
+
+References:
+  IsaacLab mesh terrain implementation:
+  https://github.com/isaac-sim/IsaacLab/blob/main/source/isaaclab/isaaclab/terrains/trimesh/mesh_terrains.py
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import mujoco
+import numpy as np
+
+from mjlab.terrains.terrain_generator import (
+  SubTerrainCfg,
+  TerrainGeometry,
+  TerrainOutput,
+)
+from mjlab.terrains.utils import make_border, make_plane
+from mjlab.utils.color import (
+  brand_ramp,
+  darken_rgba,
+)
+
+_MUJOCO_BLUE = (0.20, 0.45, 0.95)
+_MUJOCO_RED = (0.90, 0.30, 0.30)
+_MUJOCO_GREEN = (0.25, 0.80, 0.45)
+
+# Minimum vertical extent of a flat border frame, in meters. The border top sits
+# flush at z=0 and extends downward, so this depth is not visible from above; it
+# only guarantees the frame is solid (never a degenerate zero-height geom) when
+# the step height collapses to zero at difficulty 0.
+_MIN_BORDER_HEIGHT = 0.05
+
+
+@dataclass(kw_only=True)
+class BoxFlatTerrainCfg(SubTerrainCfg):
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    del difficulty, rng  # Unused.
+    body = spec.body("terrain")
+    origin = (self.size[0] / 2, self.size[1] / 2, 0.0)
+    boxes = make_plane(body, self.size, 0.0, center_zero=False)
+    box_colors = [(0.5, 0.5, 0.5, 1.0)]
+    geometry = TerrainGeometry(geom=boxes[0], color=box_colors[0])
+    return TerrainOutput(origin=np.array(origin), geometries=[geometry])
+
+
+@dataclass(kw_only=True)
+class BoxPyramidStairsTerrainCfg(SubTerrainCfg):
+  """Configuration for a pyramid stairs terrain."""
+
+  border_width: float = 0.0
+  """Width of the flat border frame around the staircase, in meters. Ignored
+  when holes is True."""
+  step_height_range: tuple[float, float]
+  """Min and max step height, in meters. Interpolated by difficulty."""
+  step_width: float
+  """Depth (run) of each step, in meters."""
+  platform_width: float = 1.0
+  """Side length of the flat square platform at the top of the staircase, in meters."""
+  holes: bool = False
+  """If True, steps form a cross pattern with empty gaps in the corners."""
+
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    del rng  # Unused.
+    boxes = []
+    box_colors = []
+
+    body = spec.body("terrain")
+
+    step_height = self.step_height_range[0] + difficulty * (
+      self.step_height_range[1] - self.step_height_range[0]
+    )
+
+    # Compute number of steps in x and y direction.
+    num_steps_x = int(
+      (self.size[0] - 2 * self.border_width - self.platform_width)
+      / (2 * self.step_width)
+    )
+    num_steps_y = int(
+      (self.size[1] - 2 * self.border_width - self.platform_width)
+      / (2 * self.step_width)
+    )
+    num_steps = max(0, int(min(num_steps_x, num_steps_y)))
+
+    first_step_rgba = brand_ramp(_MUJOCO_BLUE, 0.0)
+    border_rgba = darken_rgba(first_step_rgba, 0.85)
+
+    if self.border_width > 0.0 and not self.holes:
+      # Decouple the border's vertical extent from step_height so difficulty 0
+      # (step_height == 0) still produces a solid, gap-free frame instead of
+      # being skipped or generating degenerate zero-height geoms. The top stays
+      # flush with the ground at z=0.
+      border_height = max(step_height, _MIN_BORDER_HEIGHT)
+      border_center = (0.5 * self.size[0], 0.5 * self.size[1], -border_height / 2)
+      border_inner_size = (
+        self.size[0] - 2 * self.border_width,
+        self.size[1] - 2 * self.border_width,
+      )
+      border_boxes = make_border(
+        body, self.size, border_inner_size, border_height, border_center
+      )
+      boxes.extend(border_boxes)
+      for _ in range(len(border_boxes)):
+        box_colors.append(border_rgba)
+
+    terrain_center = [0.5 * self.size[0], 0.5 * self.size[1], 0.0]
+    terrain_size = (
+      self.size[0] - 2 * self.border_width,
+      self.size[1] - 2 * self.border_width,
+    )
+    rgba = brand_ramp(_MUJOCO_BLUE, 0.5)
+    for k in range(num_steps):
+      t = k / max(num_steps - 1, 1)
+      rgba = brand_ramp(_MUJOCO_BLUE, t)
+      for _ in range(4):
+        box_colors.append(rgba)
+
+      if self.holes:
+        box_size = (self.platform_width, self.platform_width)
+      else:
+        box_size = (
+          terrain_size[0] - 2 * k * self.step_width,
+          terrain_size[1] - 2 * k * self.step_width,
+        )
+      box_z = terrain_center[2] + k * step_height / 2.0
+      box_offset = (k + 0.5) * self.step_width
+      box_height = (k + 2) * step_height
+
+      box_dims = (box_size[0], self.step_width, box_height)
+
+      safe_size = (
+        np.maximum(1e-6, box_dims[0] / 2.0),
+        np.maximum(1e-6, box_dims[1] / 2.0),
+        np.maximum(1e-6, box_dims[2] / 2.0),
+      )
+
+      # Top.
+      box_pos = (
+        terrain_center[0],
+        terrain_center[1] + terrain_size[1] / 2.0 - box_offset,
+        box_z,
+      )
+      box = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=safe_size,
+        pos=box_pos,
+      )
+      boxes.append(box)
+
+      # Bottom.
+      box_pos = (
+        terrain_center[0],
+        terrain_center[1] - terrain_size[1] / 2.0 + box_offset,
+        box_z,
+      )
+      box = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=safe_size,
+        pos=box_pos,
+      )
+      boxes.append(box)
+
+      if self.holes:
+        box_dims = (self.step_width, box_size[1], box_height)
+      else:
+        box_dims = (
+          self.step_width,
+          box_size[1] - 2 * self.step_width,
+          box_height,
+        )
+      safe_size = (
+        np.maximum(1e-6, box_dims[0] / 2.0),
+        np.maximum(1e-6, box_dims[1] / 2.0),
+        np.maximum(1e-6, box_dims[2] / 2.0),
+      )
+
+      # Right.
+      box_pos = (
+        terrain_center[0] + terrain_size[0] / 2.0 - box_offset,
+        terrain_center[1],
+        box_z,
+      )
+      box = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=safe_size,
+        pos=box_pos,
+      )
+      boxes.append(box)
+
+      # Left.
+      box_pos = (
+        terrain_center[0] - terrain_size[0] / 2.0 + box_offset,
+        terrain_center[1],
+        box_z,
+      )
+      box = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=safe_size,
+        pos=box_pos,
+      )
+      boxes.append(box)
+
+    # Generate final box for the middle of the terrain.
+    box_dims = (
+      terrain_size[0] - 2 * num_steps * self.step_width,
+      terrain_size[1] - 2 * num_steps * self.step_width,
+      (num_steps + 2) * step_height,
+    )
+    box_pos = (
+      terrain_center[0],
+      terrain_center[1],
+      terrain_center[2] + num_steps * step_height / 2,
+    )
+    box = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_BOX,
+      size=(
+        np.maximum(1e-6, box_dims[0] / 2.0),
+        np.maximum(1e-6, box_dims[1] / 2.0),
+        np.maximum(1e-6, box_dims[2] / 2.0),
+      ),
+      pos=box_pos,
+    )
+    boxes.append(box)
+    origin = np.array(
+      [terrain_center[0], terrain_center[1], (num_steps + 1) * step_height]
+    )
+    box_colors.append(rgba)
+
+    geometries = [
+      TerrainGeometry(geom=box, color=color)
+      for box, color in zip(boxes, box_colors, strict=True)
+    ]
+    return TerrainOutput(origin=origin, geometries=geometries)
+
+
+@dataclass(kw_only=True)
+class BoxInvertedPyramidStairsTerrainCfg(BoxPyramidStairsTerrainCfg):
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    del rng  # Unused.
+    boxes = []
+    box_colors = []
+
+    body = spec.body("terrain")
+
+    step_height = self.step_height_range[0] + difficulty * (
+      self.step_height_range[1] - self.step_height_range[0]
+    )
+
+    # Compute number of steps in x and y direction.
+    num_steps_x = int(
+      (self.size[0] - 2 * self.border_width - self.platform_width)
+      / (2 * self.step_width)
+    )
+    num_steps_y = int(
+      (self.size[1] - 2 * self.border_width - self.platform_width)
+      / (2 * self.step_width)
+    )
+    num_steps = max(0, int(min(num_steps_x, num_steps_y)))
+    total_height = (num_steps + 1) * step_height
+
+    first_step_rgba = brand_ramp(_MUJOCO_RED, 0.0)
+    border_rgba = darken_rgba(first_step_rgba, 0.85)
+
+    if self.border_width > 0.0 and not self.holes:
+      # See BoxPyramidStairsTerrainCfg: keep the border solid and flush at z=0
+      # even when step_height collapses to 0 at difficulty 0.
+      border_height = max(step_height, _MIN_BORDER_HEIGHT)
+      border_center = (0.5 * self.size[0], 0.5 * self.size[1], -0.5 * border_height)
+      border_inner_size = (
+        self.size[0] - 2 * self.border_width,
+        self.size[1] - 2 * self.border_width,
+      )
+      border_boxes = make_border(
+        body, self.size, border_inner_size, border_height, border_center
+      )
+      boxes.extend(border_boxes)
+      for _ in range(len(border_boxes)):
+        box_colors.append(border_rgba)
+
+    terrain_center = [0.5 * self.size[0], 0.5 * self.size[1], 0.0]
+    terrain_size = (
+      self.size[0] - 2 * self.border_width,
+      self.size[1] - 2 * self.border_width,
+    )
+
+    rgba = brand_ramp(_MUJOCO_RED, 0.5)
+    for k in range(num_steps):
+      t = k / max(num_steps - 1, 1)
+      rgba = brand_ramp(_MUJOCO_RED, t)
+      for _ in range(4):
+        box_colors.append(rgba)
+
+      if self.holes:
+        box_size = (self.platform_width, self.platform_width)
+      else:
+        box_size = (
+          terrain_size[0] - 2 * k * self.step_width,
+          terrain_size[1] - 2 * k * self.step_width,
+        )
+
+      box_z = terrain_center[2] - total_height / 2 - (k + 1) * step_height / 2.0
+      box_offset = (k + 0.5) * self.step_width
+      box_height = total_height - (k + 1) * step_height
+
+      box_dims = (box_size[0], self.step_width, box_height)
+      safe_size = (
+        np.maximum(1e-6, box_dims[0] / 2.0),
+        np.maximum(1e-6, box_dims[1] / 2.0),
+        np.maximum(1e-6, box_dims[2] / 2.0),
+      )
+
+      # Top.
+      box_pos = (
+        terrain_center[0],
+        terrain_center[1] + terrain_size[1] / 2.0 - box_offset,
+        box_z,
+      )
+      box = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=safe_size,
+        pos=box_pos,
+      )
+      boxes.append(box)
+
+      # Bottom.
+      box_pos = (
+        terrain_center[0],
+        terrain_center[1] - terrain_size[1] / 2.0 + box_offset,
+        box_z,
+      )
+      box = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=safe_size,
+        pos=box_pos,
+      )
+      boxes.append(box)
+
+      if self.holes:
+        box_dims = (self.step_width, box_size[1], box_height)
+      else:
+        box_dims = (
+          self.step_width,
+          box_size[1] - 2 * self.step_width,
+          box_height,
+        )
+      safe_size = (
+        np.maximum(1e-6, box_dims[0] / 2.0),
+        np.maximum(1e-6, box_dims[1] / 2.0),
+        np.maximum(1e-6, box_dims[2] / 2.0),
+      )
+
+      # Right.
+      box_pos = (
+        terrain_center[0] + terrain_size[0] / 2.0 - box_offset,
+        terrain_center[1],
+        box_z,
+      )
+      box = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=safe_size,
+        pos=box_pos,
+      )
+      boxes.append(box)
+
+      # Left.
+      box_pos = (
+        terrain_center[0] - terrain_size[0] / 2.0 + box_offset,
+        terrain_center[1],
+        box_z,
+      )
+      box = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=safe_size,
+        pos=box_pos,
+      )
+      boxes.append(box)
+
+    # Generate final box for the middle of the terrain.
+    box_dims = (
+      terrain_size[0] - 2 * num_steps * self.step_width,
+      terrain_size[1] - 2 * num_steps * self.step_width,
+      step_height,
+    )
+    box_pos = (
+      terrain_center[0],
+      terrain_center[1],
+      terrain_center[2] - total_height - step_height / 2,
+    )
+    box = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_BOX,
+      size=(
+        np.maximum(1e-6, box_dims[0] / 2.0),
+        np.maximum(1e-6, box_dims[1] / 2.0),
+        np.maximum(1e-6, box_dims[2] / 2.0),
+      ),
+      pos=box_pos,
+    )
+    boxes.append(box)
+    origin = np.array(
+      [terrain_center[0], terrain_center[1], -(num_steps + 1) * step_height]
+    )
+    box_colors.append(rgba)
+
+    geometries = [
+      TerrainGeometry(geom=box, color=color)
+      for box, color in zip(boxes, box_colors, strict=True)
+    ]
+    return TerrainOutput(origin=origin, geometries=geometries)
+
+
+@dataclass(kw_only=True)
+class BoxRandomGridTerrainCfg(SubTerrainCfg):
+  grid_width: float
+  """Side length of each square grid cell, in meters."""
+  grid_height_range: tuple[float, float]
+  """Min and max grid cell height bound, in meters. Interpolated by difficulty.
+  At a given difficulty, cell heights are sampled uniformly from
+  [-bound, +bound]."""
+  platform_width: float = 1.0
+  """Side length of the flat square platform at the grid center, in meters."""
+  holes: bool = False
+  """If True, only the cross-shaped region around the center platform has grid cells."""
+  merge_similar_heights: bool = False
+  """If True, adjacent cells with similar heights are merged into larger boxes
+  to reduce geom count."""
+  height_merge_threshold: float = 0.05
+  """Maximum height difference between cells that can be merged, in meters."""
+  max_merge_distance: int = 3
+  """Maximum number of grid cells that can be merged in each direction."""
+  border_width: float = 0.25
+
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    if self.size[0] != self.size[1]:
+      raise ValueError(f"The terrain must be square. Received size: {self.size}.")
+
+    grid_height = self.grid_height_range[0] + difficulty * (
+      self.grid_height_range[1] - self.grid_height_range[0]
+    )
+
+    body = spec.body("terrain")
+
+    boxes_list = []
+    box_colors = []
+
+    num_boxes_x = int((self.size[0] - 2 * self.border_width) / self.grid_width)
+    num_boxes_y = int((self.size[1] - 2 * self.border_width) / self.grid_width)
+
+    terrain_height = 1.0
+    border_width = self.size[0] - min(num_boxes_x, num_boxes_y) * self.grid_width
+
+    if border_width <= 0:
+      raise RuntimeError(
+        "Border width must be greater than 0! Adjust the parameter 'self.grid_width'."
+      )
+
+    border_thickness = border_width / 2
+    border_center_z = -terrain_height / 2
+
+    half_size = self.size[0] / 2
+    half_border = border_thickness / 2
+    half_terrain = terrain_height / 2
+
+    first_step_rgba = brand_ramp(_MUJOCO_GREEN, 0.0)
+    border_rgba = darken_rgba(first_step_rgba, 0.85)
+
+    border_specs = [
+      (
+        (half_size, half_border, half_terrain),
+        (half_size, self.size[1] - half_border, border_center_z),
+      ),
+      (
+        (half_size, half_border, half_terrain),
+        (half_size, half_border, border_center_z),
+      ),
+      (
+        (half_border, (self.size[1] - 2 * border_thickness) / 2, half_terrain),
+        (half_border, half_size, border_center_z),
+      ),
+      (
+        (half_border, (self.size[1] - 2 * border_thickness) / 2, half_terrain),
+        (self.size[0] - half_border, half_size, border_center_z),
+      ),
+    ]
+
+    for size, pos in border_specs:
+      box = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=size,
+        pos=pos,
+      )
+      boxes_list.append(box)
+      box_colors.append(border_rgba)
+
+    height_map = rng.uniform(-grid_height, grid_height, (num_boxes_x, num_boxes_y))
+
+    if self.merge_similar_heights and not self.holes:
+      box_list_, box_color_ = self._create_merged_boxes(
+        body,
+        height_map,
+        num_boxes_x,
+        num_boxes_y,
+        grid_height,
+        terrain_height,
+        border_width,
+      )
+      boxes_list.extend(box_list_)
+      box_colors.extend(box_color_)
+    else:
+      box_list_, box_color_ = self._create_individual_boxes(
+        body,
+        height_map,
+        num_boxes_x,
+        num_boxes_y,
+        grid_height,
+        terrain_height,
+        border_width,
+      )
+      boxes_list.extend(box_list_)
+      box_colors.extend(box_color_)
+
+    # Platform
+    platform_height = terrain_height + grid_height
+    platform_center_z = -terrain_height / 2 + grid_height / 2
+    half_platform = self.platform_width / 2
+
+    box = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_BOX,
+      size=(half_platform, half_platform, platform_height / 2),
+      pos=(self.size[0] / 2, self.size[1] / 2, platform_center_z),
+    )
+    boxes_list.append(box)
+    box_colors.append(brand_ramp(_MUJOCO_GREEN, 0.5))
+
+    origin = np.array([self.size[0] / 2, self.size[1] / 2, grid_height])
+
+    geometries = [
+      TerrainGeometry(geom=box, color=color)
+      for box, color in zip(boxes_list, box_colors, strict=True)
+    ]
+    return TerrainOutput(origin=origin, geometries=geometries)
+
+  def _create_merged_boxes(
+    self,
+    body,
+    height_map,
+    num_boxes_x,
+    num_boxes_y,
+    grid_height,
+    terrain_height,
+    border_width,
+  ):
+    """Create merged boxes for similar heights to reduce geom count."""
+    boxes = []
+    box_colors = []
+    visited = np.zeros((num_boxes_x, num_boxes_y), dtype=bool)
+
+    half_border_width = border_width / 2
+    neg_half_terrain = -terrain_height / 2
+
+    # Mark cells under the center platform as visited so they are never emitted
+    # or merged; the platform box covers that region and would otherwise z-fight
+    # with the cells beneath it.
+    platform_half = self.platform_width / 2
+    terrain_center = self.size[0] / 2
+    platform_min = terrain_center - platform_half
+    platform_max = terrain_center + platform_half
+    for i in range(num_boxes_x):
+      cx = half_border_width + (i + 0.5) * self.grid_width
+      if not (platform_min <= cx <= platform_max):
+        continue
+      for j in range(num_boxes_y):
+        cy = half_border_width + (j + 0.5) * self.grid_width
+        if platform_min <= cy <= platform_max:
+          visited[i, j] = True
+
+    # Quantize heights to create more merging opportunities
+    quantized_heights = (
+      np.round(height_map / self.height_merge_threshold) * self.height_merge_threshold
+    )
+
+    for i in range(num_boxes_x):
+      for j in range(num_boxes_y):
+        if visited[i, j]:
+          continue
+
+        # Find rectangular region with similar height
+        height = quantized_heights[i, j]
+
+        # grid_height == 0 (difficulty 0) means a flat grid; use the midpoint
+        # color and avoid dividing by zero.
+        if grid_height > 0:
+          normalized_height = (height + grid_height) / (2 * grid_height)
+        else:
+          normalized_height = 0.5
+        t = float(np.clip(normalized_height, 0.0, 1.0))
+        rgba = brand_ramp(_MUJOCO_GREEN, t)
+
+        # Greedy expansion in x and y directions
+        max_x = i + 1
+        max_y = j + 1
+
+        # Try to expand in x direction first
+        while max_x < min(i + self.max_merge_distance, num_boxes_x):
+          if not visited[max_x, j] and abs(quantized_heights[max_x, j] - height) < 1e-6:
+            max_x += 1
+          else:
+            break
+
+        # Then expand in y direction for the found x range
+        can_expand_y = True
+        while max_y < min(j + self.max_merge_distance, num_boxes_y) and can_expand_y:
+          for x in range(i, max_x):
+            if visited[x, max_y] or abs(quantized_heights[x, max_y] - height) > 1e-6:
+              can_expand_y = False
+              break
+          if can_expand_y:
+            max_y += 1
+
+        # Mark region as visited
+        visited[i:max_x, j:max_y] = True
+
+        # Create merged box
+        width_x = (max_x - i) * self.grid_width
+        width_y = (max_y - j) * self.grid_width
+
+        box_center_x = half_border_width + (i + (max_x - i) / 2) * self.grid_width
+        box_center_y = half_border_width + (j + (max_y - j) / 2) * self.grid_width
+
+        box_height = terrain_height + height
+        box_center_z = neg_half_terrain + height / 2
+
+        box = body.add_geom(
+          type=mujoco.mjtGeom.mjGEOM_BOX,
+          size=(width_x / 2, width_y / 2, box_height / 2),
+          pos=(box_center_x, box_center_y, box_center_z),
+        )
+        boxes.append(box)
+        box_colors.append(rgba)
+
+    return boxes, box_colors
+
+  def _create_individual_boxes(
+    self,
+    body,
+    height_map,
+    num_boxes_x,
+    num_boxes_y,
+    grid_height,
+    terrain_height,
+    border_width,
+  ):
+    """Original approach with individual boxes."""
+    boxes = []
+    box_colors = []
+    half_grid = self.grid_width / 2
+    half_border_width = border_width / 2
+    neg_half_terrain = -terrain_height / 2
+
+    platform_half = self.platform_width / 2
+    terrain_center = self.size[0] / 2
+    platform_min = terrain_center - platform_half
+    platform_max = terrain_center + platform_half
+
+    for i in range(num_boxes_x):
+      box_center_x = half_border_width + (i + 0.5) * self.grid_width
+
+      if self.holes and not (platform_min <= box_center_x <= platform_max):
+        in_y_strip = False
+      else:
+        in_y_strip = True
+
+      for j in range(num_boxes_y):
+        box_center_y = half_border_width + (j + 0.5) * self.grid_width
+
+        if self.holes:
+          in_x_strip = platform_min <= box_center_y <= platform_max
+          if not (in_x_strip or in_y_strip):
+            continue
+
+        # Skip cells under the center platform so the platform is the only
+        # geometry there. Otherwise the platform box sits on top of these cells
+        # and the coplanar faces z-fight.
+        if (platform_min <= box_center_x <= platform_max) and (
+          platform_min <= box_center_y <= platform_max
+        ):
+          continue
+
+        height_noise = height_map[i, j]
+        box_height = terrain_height + height_noise
+        box_center_z = neg_half_terrain + height_noise / 2
+
+        # grid_height == 0 (difficulty 0) means a flat grid; use the midpoint
+        # color and avoid dividing by zero.
+        if grid_height > 0:
+          normalized_height = (height_noise + grid_height) / (2 * grid_height)
+        else:
+          normalized_height = 0.5
+        t = float(np.clip(normalized_height, 0.0, 1.0))
+        rgba = brand_ramp(_MUJOCO_GREEN, t)
+        box_colors.append(rgba)
+
+        box = body.add_geom(
+          type=mujoco.mjtGeom.mjGEOM_BOX,
+          size=(half_grid, half_grid, box_height / 2),
+          pos=(box_center_x, box_center_y, box_center_z),
+        )
+        boxes.append(box)
+
+    return boxes, box_colors
+
+
+@dataclass(kw_only=True)
+class BoxRandomSpreadTerrainCfg(SubTerrainCfg):
+  num_boxes: int = 60
+  box_width_range: tuple[float, float] = (0.3, 1.0)
+  box_length_range: tuple[float, float] = (0.3, 1.0)
+  box_height_range: tuple[float, float] = (0.05, 1.0)
+  box_yaw_range: tuple[float, float] = (0.0, 360.0)
+  add_floor: bool = True
+  platform_width: float = 1.0
+  border_width: float = 0.25
+
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    body = spec.body("terrain")
+    geometries = []
+
+    # Scale number of boxes by difficulty.
+    num_boxes = int(self.num_boxes * (0.5 + 0.5 * difficulty))
+
+    terrain_height = 1.0
+    border_rgba = darken_rgba(brand_ramp(_MUJOCO_BLUE, 0.0), 0.85)
+
+    if self.border_width > 0.0:
+      border_center = (0.5 * self.size[0], 0.5 * self.size[1], -terrain_height / 2)
+      border_inner_size = (
+        np.maximum(1e-6, self.size[0] - 2 * self.border_width),
+        np.maximum(1e-6, self.size[1] - 2 * self.border_width),
+      )
+      border_boxes = make_border(
+        body, self.size, border_inner_size, terrain_height, border_center
+      )
+      for box in border_boxes:
+        geometries.append(TerrainGeometry(geom=box, color=border_rgba))
+
+    if self.add_floor:
+      floor_geom = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=(
+          (self.size[0] - 2 * self.border_width) / 2,
+          (self.size[1] - 2 * self.border_width) / 2,
+          0.05,
+        ),
+        pos=(self.size[0] / 2, self.size[1] / 2, -0.05),
+      )
+      geometries.append(TerrainGeometry(geom=floor_geom, color=(0.4, 0.4, 0.4, 1.0)))
+
+    # Center platform. When a floor is present it already provides flat ground at
+    # z=0 across the (box-free) center, so an extra platform box would only
+    # duplicate that surface and z-fight with the floor. Add the platform only
+    # when there is no floor, where it is the sole ground at the spawn point.
+    if not self.add_floor:
+      platform_geom = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=(self.platform_width / 2, self.platform_width / 2, terrain_height / 2),
+        pos=(self.size[0] / 2, self.size[1] / 2, -terrain_height / 2),
+      )
+      geometries.append(TerrainGeometry(geom=platform_geom, color=(0.4, 0.4, 0.4, 1.0)))
+
+    platform_half = self.platform_width / 2
+    terrain_center = self.size[0] / 2
+    platform_min = terrain_center - platform_half
+    platform_max = terrain_center + platform_half
+
+    for _ in range(num_boxes):
+      # Random size.
+      size_x = rng.uniform(*self.box_width_range)
+      size_y = rng.uniform(*self.box_length_range)
+      height = rng.uniform(*self.box_height_range)
+
+      # Scale height by difficulty.
+      height = height * (0.2 + 0.8 * difficulty)
+
+      # Random position within inner area.
+      pos_x = rng.uniform(
+        self.border_width + size_x / 2, self.size[0] - self.border_width - size_x / 2
+      )
+      pos_y = rng.uniform(
+        self.border_width + size_y / 2, self.size[1] - self.border_width - size_y / 2
+      )
+
+      # Avoid platform.
+      if (platform_min - size_x / 2 <= pos_x <= platform_max + size_x / 2) and (
+        platform_min - size_y / 2 <= pos_y <= platform_max + size_y / 2
+      ):
+        continue
+
+      pos_z = height / 2
+
+      # Random orientation (yaw).
+      yaw = np.deg2rad(rng.uniform(*self.box_yaw_range))
+
+      rgba = brand_ramp(_MUJOCO_BLUE, rng.uniform(0.3, 0.8))
+
+      geom = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=(
+          np.maximum(1e-6, size_x / 2),
+          np.maximum(1e-6, size_y / 2),
+          np.maximum(1e-6, height / 2),
+        ),
+        pos=(pos_x, pos_y, pos_z),
+      )
+      # MuJoCo quat is (w, x, y, z).
+      geom.quat = np.array([np.cos(yaw / 2), 0, 0, np.sin(yaw / 2)])
+      geometries.append(TerrainGeometry(geom=geom, color=rgba))
+
+    origin = np.array([self.size[0] / 2, self.size[1] / 2, 0.0])
+    return TerrainOutput(origin=origin, geometries=geometries)
+
+
+@dataclass(kw_only=True)
+class BoxOpenStairsTerrainCfg(SubTerrainCfg):
+  step_height_range: tuple[float, float] = (0.1, 0.2)
+  step_width_range: tuple[float, float] = (0.4, 0.8)
+  platform_width: float = 1.0
+  border_width: float = 0.25
+  step_thickness: float = 0.05
+  inverted: bool = True
+
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    del rng  # Unused.
+    body = spec.body("terrain")
+    geometries = []
+
+    step_height = self.step_height_range[0] + difficulty * (
+      self.step_height_range[1] - self.step_height_range[0]
+    )
+    step_width = self.step_width_range[1] - difficulty * (
+      self.step_width_range[1] - self.step_width_range[0]
+    )
+
+    # Compute number of steps.
+    num_steps_x = int(
+      (self.size[0] - 2 * self.border_width - self.platform_width) / (2 * step_width)
+    )
+    num_steps_y = int(
+      (self.size[1] - 2 * self.border_width - self.platform_width) / (2 * step_width)
+    )
+    num_steps = int(min(num_steps_x, num_steps_y))
+
+    first_step_rgba = brand_ramp(_MUJOCO_BLUE, 0.0)
+    border_rgba = darken_rgba(first_step_rgba, 0.85)
+
+    if self.border_width > 0.0:
+      # Keep the border solid and flush at z=0 even if step_height is 0.
+      border_height = max(step_height, _MIN_BORDER_HEIGHT)
+      border_center = (0.5 * self.size[0], 0.5 * self.size[1], -border_height / 2)
+      border_inner_size = (
+        self.size[0] - 2 * self.border_width,
+        self.size[1] - 2 * self.border_width,
+      )
+      border_boxes = make_border(
+        body, self.size, border_inner_size, border_height, border_center
+      )
+      for box in border_boxes:
+        geometries.append(TerrainGeometry(geom=box, color=border_rgba))
+
+    terrain_center = [0.5 * self.size[0], 0.5 * self.size[1], 0.0]
+    terrain_size = (
+      self.size[0] - 2 * self.border_width,
+      self.size[1] - 2 * self.border_width,
+    )
+
+    rgba = brand_ramp(_MUJOCO_BLUE, 0.5)
+    for k in range(num_steps):
+      t = k / max(num_steps - 1, 1)
+      rgba = brand_ramp(_MUJOCO_BLUE, t)
+
+      box_size = (
+        terrain_size[0] - 2 * k * step_width,
+        terrain_size[1] - 2 * k * step_width,
+      )
+
+      # Inverted: Outer steps (small k) are higher (Bowl).
+      # Normal: Inner steps (large k) are higher (Pyramid).
+      if self.inverted:
+        # Highest step (k=0) top is at 0 (border height).
+        z_pos = -k * step_height - 0.5 * self.step_thickness
+      else:
+        # Lowest step (k=0) top is at step_height.
+        z_pos = (k + 1) * step_height - 0.5 * self.step_thickness
+
+      box_offset = (k + 0.5) * step_width
+
+      # Top.
+      box_pos = (
+        terrain_center[0],
+        terrain_center[1] + terrain_size[1] / 2.0 - box_offset,
+        z_pos,
+      )
+      box = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=(
+          np.maximum(1e-6, box_size[0] / 2.0),
+          np.maximum(1e-6, step_width / 2.0),
+          self.step_thickness / 2.0,
+        ),
+        pos=box_pos,
+      )
+      geometries.append(TerrainGeometry(geom=box, color=rgba))
+
+      # Bottom.
+      box_pos = (
+        terrain_center[0],
+        terrain_center[1] - terrain_size[1] / 2.0 + box_offset,
+        z_pos,
+      )
+      box = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=(
+          np.maximum(1e-6, box_size[0] / 2.0),
+          np.maximum(1e-6, step_width / 2.0),
+          self.step_thickness / 2.0,
+        ),
+        pos=box_pos,
+      )
+      geometries.append(TerrainGeometry(geom=box, color=rgba))
+
+      # Right.
+      box_pos = (
+        terrain_center[0] + terrain_size[0] / 2.0 - box_offset,
+        terrain_center[1],
+        z_pos,
+      )
+      box = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=(
+          np.maximum(1e-6, step_width / 2.0),
+          np.maximum(1e-6, (box_size[1] - 2 * step_width) / 2.0),
+          self.step_thickness / 2.0,
+        ),
+        pos=box_pos,
+      )
+      geometries.append(TerrainGeometry(geom=box, color=rgba))
+
+      # Left.
+      box_pos = (
+        terrain_center[0] - terrain_size[0] / 2.0 + box_offset,
+        terrain_center[1],
+        z_pos,
+      )
+      box = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=(
+          np.maximum(1e-6, step_width / 2.0),
+          np.maximum(1e-6, (box_size[1] - 2 * step_width) / 2.0),
+          self.step_thickness / 2.0,
+        ),
+        pos=box_pos,
+      )
+      geometries.append(TerrainGeometry(geom=box, color=rgba))
+
+    # Platform.
+    platform_size = (
+      np.maximum(1e-6, terrain_size[0] - 2 * num_steps * step_width),
+      np.maximum(1e-6, terrain_size[1] - 2 * num_steps * step_width),
+    )
+    # Bowl: Align bottom (ground level).
+    # Bowl: Highest step is border level. Platform is at bottom.
+    # Pyramid: Align top-most level.
+    if self.inverted:
+      platform_h_center = -num_steps * step_height - 0.5 * self.step_thickness
+    else:
+      platform_h_center = (num_steps + 1) * step_height - 0.5 * self.step_thickness
+
+    platform_pos = (terrain_center[0], terrain_center[1], platform_h_center)
+    box = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_BOX,
+      size=(platform_size[0] / 2.0, platform_size[1] / 2.0, self.step_thickness / 2.0),
+      pos=platform_pos,
+    )
+    geometries.append(TerrainGeometry(geom=box, color=rgba))
+
+    origin = np.array(
+      [
+        terrain_center[0],
+        terrain_center[1],
+        platform_h_center + self.step_thickness / 2.0,
+      ]
+    )
+    return TerrainOutput(origin=origin, geometries=geometries)
+
+
+@dataclass(kw_only=True)
+class BoxRandomStairsTerrainCfg(SubTerrainCfg):
+  step_width: float = 0.8
+  step_height_range: tuple[float, float] = (0.1, 0.3)
+  platform_width: float = 1.0
+  border_width: float = 0.25
+
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    body = spec.body("terrain")
+    geometries = []
+
+    # Compute number of steps.
+    num_steps_x = int(
+      (self.size[0] - 2 * self.border_width - self.platform_width)
+      / (2 * self.step_width)
+    )
+    num_steps_y = int(
+      (self.size[1] - 2 * self.border_width - self.platform_width)
+      / (2 * self.step_width)
+    )
+    num_steps = int(min(num_steps_x, num_steps_y))
+
+    first_step_rgba = brand_ramp(_MUJOCO_BLUE, 0.0)
+    border_rgba = darken_rgba(first_step_rgba, 0.85)
+
+    if self.border_width > 0.0:
+      border_center = (0.5 * self.size[0], 0.5 * self.size[1], -0.05)
+      border_inner_size = (
+        self.size[0] - 2 * self.border_width,
+        self.size[1] - 2 * self.border_width,
+      )
+      border_boxes = make_border(body, self.size, border_inner_size, 0.1, border_center)
+      for box in border_boxes:
+        geometries.append(TerrainGeometry(geom=box, color=border_rgba))
+
+    terrain_center = [0.5 * self.size[0], 0.5 * self.size[1], 0.0]
+    terrain_size = (
+      self.size[0] - 2 * self.border_width,
+      self.size[1] - 2 * self.border_width,
+    )
+
+    rgba = brand_ramp(_MUJOCO_BLUE, 0.5)
+    current_z = 0.0
+    for k in range(num_steps):
+      t = k / max(num_steps - 1, 1)
+      rgba = brand_ramp(_MUJOCO_BLUE, t)
+
+      h_low, h_high = self.step_height_range
+      step_h = rng.uniform(h_low, h_high) * (0.5 + 0.5 * difficulty)
+      total_h = current_z + step_h
+
+      box_size = (
+        terrain_size[0] - 2 * k * self.step_width,
+        terrain_size[1] - 2 * k * self.step_width,
+      )
+
+      z_pos = total_h / 2
+      box_offset = (k + 0.5) * self.step_width
+
+      # Top.
+      box_pos = (
+        terrain_center[0],
+        terrain_center[1] + terrain_size[1] / 2.0 - box_offset,
+        z_pos,
+      )
+      box = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=(
+          np.maximum(1e-6, box_size[0] / 2.0),
+          np.maximum(1e-6, self.step_width / 2.0),
+          np.maximum(1e-6, total_h / 2.0),
+        ),
+        pos=box_pos,
+      )
+      geometries.append(TerrainGeometry(geom=box, color=rgba))
+
+      # Bottom.
+      box_pos = (
+        terrain_center[0],
+        terrain_center[1] - terrain_size[1] / 2.0 + box_offset,
+        z_pos,
+      )
+      box = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=(
+          np.maximum(1e-6, box_size[0] / 2.0),
+          np.maximum(1e-6, self.step_width / 2.0),
+          np.maximum(1e-6, total_h / 2.0),
+        ),
+        pos=box_pos,
+      )
+      geometries.append(TerrainGeometry(geom=box, color=rgba))
+
+      # Right.
+      box_pos = (
+        terrain_center[0] + terrain_size[0] / 2.0 - box_offset,
+        terrain_center[1],
+        z_pos,
+      )
+      box = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=(
+          np.maximum(1e-6, self.step_width / 2.0),
+          np.maximum(1e-6, (box_size[1] - 2 * self.step_width) / 2.0),
+          np.maximum(1e-6, total_h / 2.0),
+        ),
+        pos=box_pos,
+      )
+      geometries.append(TerrainGeometry(geom=box, color=rgba))
+
+      # Left.
+      box_pos = (
+        terrain_center[0] - terrain_size[0] / 2.0 + box_offset,
+        terrain_center[1],
+        z_pos,
+      )
+      box = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=(
+          np.maximum(1e-6, self.step_width / 2.0),
+          np.maximum(1e-6, (box_size[1] - 2 * self.step_width) / 2.0),
+          np.maximum(1e-6, total_h / 2.0),
+        ),
+        pos=box_pos,
+      )
+      geometries.append(TerrainGeometry(geom=box, color=rgba))
+
+      current_z = total_h
+
+    # Platform
+    platform_size = (
+      np.maximum(1e-6, terrain_size[0] - 2 * num_steps * self.step_width),
+      np.maximum(1e-6, terrain_size[1] - 2 * num_steps * self.step_width),
+    )
+    platform_pos = (terrain_center[0], terrain_center[1], current_z / 2)
+    box = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_BOX,
+      size=(
+        platform_size[0] / 2.0,
+        platform_size[1] / 2.0,
+        np.maximum(1e-6, current_z / 2.0),
+      ),
+      pos=platform_pos,
+    )
+    geometries.append(TerrainGeometry(geom=box, color=rgba))
+
+    origin = np.array([terrain_center[0], terrain_center[1], current_z])
+    return TerrainOutput(origin=origin, geometries=geometries)
+
+
+@dataclass(kw_only=True)
+class BoxSteppingStonesTerrainCfg(SubTerrainCfg):
+  stone_size_range: tuple[float, float] = (0.4, 0.8)
+  """Max and min stone side length, in meters. Stones shrink from the max toward
+  the min as difficulty increases, which widens the gaps between them."""
+  stone_distance_range: tuple[float, float] = (0.2, 0.5)
+  """Gap between stones, in meters. The lower bound seeds the (fixed) grid
+  density; the gap itself grows with difficulty as the stones shrink, so the
+  upper bound is no longer used directly."""
+  stone_height: float = 0.2
+  stone_height_variation: float = 0.1
+  stone_size_variation: float = 0.1
+  floor_depth: float = 2.0
+  displacement_range: float = 0.1
+  platform_width: float = 1.0
+  border_width: float = 0.25
+
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    body = spec.body("terrain")
+    geometries = []
+
+    # Difficulty-scaled variations.
+    stone_size_variation = self.stone_size_variation * difficulty
+    displacement_range = self.displacement_range * difficulty
+    stone_height_variation = self.stone_height_variation * difficulty
+
+    # Decrease stone size with difficulty (larger stones are easier). With the
+    # grid pitch held fixed (below), shrinking stones means the gaps between them
+    # grow, which is the actual difficulty curriculum.
+    s_min, s_max = self.stone_size_range
+    avg_stone_size = s_max - difficulty * (s_max - s_min)
+
+    # Difficulty-INDEPENDENT grid. The count and pitch are fixed across difficulty
+    # so the layout never re-tiles (previously, num = floor(inner / spacing) + 1
+    # jumped by one as the difficulty-varying spacing crossed an integer boundary,
+    # shifting every stone at once). The pitch exactly spans the inner region so
+    # edge stones always reach the borders. Density is seeded by the tightest
+    # nominal spacing (largest stones + smallest gap).
+    inner_w = self.size[0] - 2 * self.border_width
+    inner_h = self.size[1] - 2 * self.border_width
+    nominal_spacing = s_max + self.stone_distance_range[0]
+    num_x = max(2, int(np.floor(inner_w / nominal_spacing)) + 1)
+    num_y = max(2, int(np.floor(inner_h / nominal_spacing)) + 1)
+    pitch_x = inner_w / (num_x - 1)
+    pitch_y = inner_h / (num_y - 1)
+
+    # Inter-stone gap (grows with difficulty as stones shrink).
+    gap_x = max(0.0, pitch_x - avg_stone_size)
+    gap_y = max(0.0, pitch_y - avg_stone_size)
+
+    # Snap the central platform out to the grid. It is at least the configured
+    # width and reaches to exactly one gap before the nearest *full* stone, so the
+    # ring of stones around it are whole (no clipped slivers that pop in and out
+    # with difficulty) and sit one consistent gap away. The platform simply
+    # absorbs the stones that would otherwise be partially under it.
+    center_x, center_y = self.size[0] / 2, self.size[1] / 2
+    half_stone = avg_stone_size / 2
+    a0 = self.platform_width / 2
+
+    def _snapped_half(center: float, pitch: float, gap: float, num: int) -> float:
+      # Nearest grid stone that can stay full while the platform is >= a0 wide.
+      threshold = center + a0 + half_stone + gap
+      i_keep = min(num - 1, int(np.ceil((threshold - self.border_width) / pitch)))
+      c_keep = self.border_width + i_keep * pitch
+      return max(a0, c_keep - half_stone - gap - center)
+
+    platform_half_x = _snapped_half(center_x, pitch_x, gap_x, num_x)
+    platform_half_y = _snapped_half(center_y, pitch_y, gap_y, num_y)
+    platform_min_x, platform_max_x = (
+      center_x - platform_half_x,
+      center_x + platform_half_x,
+    )
+    platform_min_y, platform_max_y = (
+      center_y - platform_half_y,
+      center_y + platform_half_y,
+    )
+
+    border_rgba = darken_rgba(brand_ramp(_MUJOCO_GREEN, 0.0), 0.85)
+    z_center = (self.stone_height - self.floor_depth) / 2
+    half_height = (self.stone_height + self.floor_depth) / 2
+
+    if self.border_width > 0.0:
+      border_center = (0.5 * self.size[0], 0.5 * self.size[1], z_center)
+      border_boxes = make_border(
+        body,
+        self.size,
+        (self.size[0] - 2 * self.border_width, self.size[1] - 2 * self.border_width),
+        self.stone_height + self.floor_depth,
+        border_center,
+      )
+      for b_geom in border_boxes:
+        geometries.append(TerrainGeometry(geom=b_geom, color=border_rgba))
+
+    # Ground floor (deep pit).
+    floor_h = 0.1
+    floor_geom = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_BOX,
+      size=(self.size[0] / 2, self.size[1] / 2, floor_h / 2),
+      pos=(self.size[0] / 2, self.size[1] / 2, -self.floor_depth - floor_h / 2),
+    )
+    geometries.append(TerrainGeometry(geom=floor_geom, color=(0.1, 0.1, 0.1, 1.0)))
+
+    # Platform Column (grid-snapped, see above).
+    platform_geom = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_BOX,
+      size=(
+        np.maximum(1e-6, platform_half_x),
+        np.maximum(1e-6, platform_half_y),
+        np.maximum(1e-6, half_height),
+      ),
+      pos=(center_x, center_y, z_center),
+    )
+    geometries.append(
+      TerrainGeometry(geom=platform_geom, color=brand_ramp(_MUJOCO_GREEN, 0.5))
+    )
+
+    inner_min_x, inner_max_x = self.border_width, self.size[0] - self.border_width
+    inner_min_y, inner_max_y = self.border_width, self.size[1] - self.border_width
+
+    for i in range(num_x):
+      for j in range(num_y):
+        base_size = avg_stone_size
+
+        # Proposed position on the fixed grid with random displacement. Centers
+        # span border to (size - border), so edge stones reach the borders.
+        px = (
+          self.border_width
+          + i * pitch_x
+          + rng.uniform(-displacement_range, displacement_range)
+        )
+        py = (
+          self.border_width
+          + j * pitch_y
+          + rng.uniform(-displacement_range, displacement_range)
+        )
+
+        # Randomized size.
+        size_x = base_size + rng.uniform(-stone_size_variation, stone_size_variation)
+        size_y = base_size + rng.uniform(-stone_size_variation, stone_size_variation)
+
+        # Initial bounds.
+        x_min, x_max = px - size_x / 2, px + size_x / 2
+        y_min, y_max = py - size_y / 2, py + size_y / 2
+
+        # Drop stones whose center lies under the (grid-snapped) platform; the
+        # platform absorbs them. Every remaining stone stays full size and sits
+        # one gap from the platform, so there are no clipped slivers.
+        if (platform_min_x <= px <= platform_max_x) and (
+          platform_min_y <= py <= platform_max_y
+        ):
+          continue
+
+        # Final clip against border.
+        x_min = np.clip(x_min, inner_min_x, inner_max_x)
+        x_max = np.clip(x_max, inner_min_x, inner_max_x)
+        y_min = np.clip(y_min, inner_min_y, inner_max_y)
+        y_max = np.clip(y_max, inner_min_y, inner_max_y)
+
+        clipped_sx = x_max - x_min
+        clipped_sy = y_max - y_min
+        clipped_px = (x_min + x_max) / 2
+        clipped_py = (y_min + y_max) / 2
+
+        if clipped_sx < 0.05 or clipped_sy < 0.05:
+          continue
+
+        # Stones grow from the floor up to around ground level.
+        h = (
+          self.floor_depth
+          + self.stone_height
+          + rng.uniform(-stone_height_variation, stone_height_variation)
+        )
+        pos_z = -self.floor_depth + h / 2
+
+        rgba = brand_ramp(_MUJOCO_GREEN, rng.uniform(0.4, 0.7))
+
+        geom = body.add_geom(
+          type=mujoco.mjtGeom.mjGEOM_BOX,
+          size=(
+            np.maximum(1e-6, clipped_sx / 2),
+            np.maximum(1e-6, clipped_sy / 2),
+            np.maximum(1e-6, h / 2),
+          ),
+          pos=(clipped_px, clipped_py, pos_z),
+        )
+        geometries.append(TerrainGeometry(geom=geom, color=rgba))
+
+    origin = np.array([self.size[0] / 2, self.size[1] / 2, self.stone_height])
+    return TerrainOutput(origin=origin, geometries=geometries)
+
+
+@dataclass(kw_only=True)
+class BoxNarrowBeamsTerrainCfg(SubTerrainCfg):
+  num_beams: int = 16
+  beam_width_range: tuple[float, float] = (0.2, 0.4)
+  beam_height: float = 0.2
+  spacing: float = 0.8
+  platform_width: float = 1.0
+  border_width: float = 0.25
+  floor_depth: float = 2.0
+
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    del rng  # Beam layout is deterministic.
+    body = spec.body("terrain")
+    geometries = []
+
+    # Number of beams can be increased with difficulty if desired.
+    num_beams = int(self.num_beams)
+
+    # Narrower beams with difficulty (interp from max to min).
+    w_min, w_max = self.beam_width_range
+    beam_width = w_max - difficulty * (w_max - w_min)
+
+    # Shrink the square platform so its corners stay within the beams' angular
+    # coverage rather than protruding into the pit between beams. A corner sits at
+    # radius r*sqrt(2) and, in the worst case, pi/num_beams away from the nearest
+    # beam, so it is covered while r*sqrt(2)*sin(pi/num_beams) <= beam_width/2.
+    # Beams thin with difficulty, so the safe radius shrinks with it. The beams
+    # attach at this same radius (below), so shrinking never opens a fall gap.
+    spacing_sin = float(np.sin(np.pi / num_beams)) if num_beams > 1 else 0.0
+    if spacing_sin > 1e-9:
+      max_no_protrude = beam_width / (2.0 * np.sqrt(2.0) * spacing_sin)
+      platform_radius = float(min(self.platform_width / 2.0, max_no_protrude))
+    else:
+      platform_radius = self.platform_width / 2.0
+
+    border_rgba = darken_rgba(brand_ramp(_MUJOCO_BLUE, 0.0), 0.85)
+    z_center = (self.beam_height - self.floor_depth) / 2
+    half_height = (self.beam_height + self.floor_depth) / 2
+
+    if self.border_width > 0.0:
+      border_center = (0.5 * self.size[0], 0.5 * self.size[1], z_center)
+      border_boxes = make_border(
+        body,
+        self.size,
+        (self.size[0] - 2 * self.border_width, self.size[1] - 2 * self.border_width),
+        self.beam_height + self.floor_depth,
+        border_center,
+      )
+      for b_geom in border_boxes:
+        geometries.append(TerrainGeometry(geom=b_geom, color=border_rgba))
+
+    # Ground floor (deep pit).
+    floor_h = 0.1
+    floor_geom = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_BOX,
+      size=(self.size[0] / 2, self.size[1] / 2, floor_h / 2),
+      pos=(self.size[0] / 2, self.size[1] / 2, -self.floor_depth - floor_h / 2),
+    )
+    geometries.append(TerrainGeometry(geom=floor_geom, color=(0.1, 0.1, 0.1, 1.0)))
+
+    # Platform Column. Top at beam_height.
+    platform_geom = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_BOX,
+      size=(
+        np.maximum(1e-6, platform_radius),
+        np.maximum(1e-6, platform_radius),
+        np.maximum(1e-6, half_height),
+      ),
+      pos=(self.size[0] / 2, self.size[1] / 2, z_center),
+    )
+    geometries.append(
+      TerrainGeometry(geom=platform_geom, color=brand_ramp(_MUJOCO_BLUE, 0.5))
+    )
+
+    inner_size = self.size[0] - 2 * self.border_width
+    center_x, center_y = self.size[0] / 2, self.size[1] / 2
+
+    # Radial beams as columns.
+    angles = np.linspace(0, 2 * np.pi, num_beams, endpoint=False)
+    for angle in angles:
+      # Distance to the square border at this angle.
+      # r = (L/2) / max(|cos(theta)|, |sin(theta)|)
+      cos_a = abs(np.cos(angle))
+      sin_a = abs(np.sin(angle))
+      dist_to_border = (inner_size / 2) / max(cos_a, sin_a)
+
+      # Additional length so that the farthest corner reaches the border.
+      # delta_L = (w/2) * tan(local_theta) = (w/2) * min(cos, sin) / max(cos, sin)
+      extra_length = (beam_width / 2) * min(cos_a, sin_a) / max(cos_a, sin_a)
+
+      beam_length = dist_to_border + extra_length - platform_radius
+
+      dist_to_center = platform_radius + beam_length / 2
+      px = center_x + dist_to_center * np.cos(angle)
+      py = center_y + dist_to_center * np.sin(angle)
+      pz = z_center
+
+      geom = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=(
+          np.maximum(1e-6, beam_length / 2),
+          np.maximum(1e-6, beam_width / 2),
+          np.maximum(1e-6, half_height),
+        ),
+        pos=(px, py, pz),
+      )
+      # Quat for yaw = angle.
+      geom.quat = np.array([np.cos(angle / 2), 0, 0, np.sin(angle / 2)])
+      geometries.append(TerrainGeometry(geom=geom, color=brand_ramp(_MUJOCO_BLUE, 0.5)))
+
+    origin = np.array([self.size[0] / 2, self.size[1] / 2, self.beam_height])
+    return TerrainOutput(origin=origin, geometries=geometries)
+
+
+@dataclass(kw_only=True)
+class BoxTiltedGridTerrainCfg(SubTerrainCfg):
+  grid_width: float = 1.0
+  tilt_range_deg: float = 15.0
+  height_range: float = 0.1
+  platform_width: float = 1.0
+  border_width: float = 0.25
+  floor_depth: float = 2.0
+
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    body = spec.body("terrain")
+    geometries = []
+
+    # Difficulty-scaled variations.
+    max_tilt = np.deg2rad(self.tilt_range_deg * difficulty)
+    actual_range = self.height_range * difficulty
+
+    # Logic adopted from BoxRandomGridTerrainCfg for consistent alignment.
+    num_boxes_x = int((self.size[0] - 2 * self.border_width) / self.grid_width)
+    num_boxes_y = int((self.size[1] - 2 * self.border_width) / self.grid_width)
+
+    border_actual = self.size[0] - num_boxes_x * self.grid_width
+    half_border = border_actual / 2
+
+    border_rgba = darken_rgba(brand_ramp(_MUJOCO_GREEN, 0.0), 0.85)
+    base_h = 0.2
+    z_center = (base_h - self.floor_depth) / 2
+    half_height = (base_h + self.floor_depth) / 2
+
+    # Border.
+    if border_actual > 0:
+      border_center = (self.size[0] / 2, self.size[1] / 2, z_center)
+      border_boxes = make_border(
+        body,
+        self.size,
+        (num_boxes_x * self.grid_width, num_boxes_y * self.grid_width),
+        base_h + self.floor_depth,
+        border_center,
+      )
+      for b_geom in border_boxes:
+        geometries.append(TerrainGeometry(geom=b_geom, color=border_rgba))
+
+    # Ground floor.
+    floor_h = 0.1
+    floor_geom = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_BOX,
+      size=(self.size[0] / 2, self.size[1] / 2, floor_h / 2),
+      pos=(self.size[0] / 2, self.size[1] / 2, -self.floor_depth - floor_h / 2),
+    )
+    geometries.append(TerrainGeometry(geom=floor_geom, color=(0.1, 0.1, 0.1, 1.0)))
+
+    # Platform.
+    platform_geom = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_BOX,
+      size=(self.platform_width / 2, self.platform_width / 2, half_height),
+      pos=(self.size[0] / 2, self.size[1] / 2, z_center),
+    )
+    geometries.append(
+      TerrainGeometry(geom=platform_geom, color=brand_ramp(_MUJOCO_GREEN, 0.5))
+    )
+
+    platform_half = self.platform_width / 2
+    terrain_center = self.size[0] / 2
+    platform_min = terrain_center - platform_half
+    platform_max = terrain_center + platform_half
+
+    for i in range(num_boxes_x):
+      bx_center = half_border + (i + 0.5) * self.grid_width
+      for j in range(num_boxes_y):
+        by_center = half_border + (j + 0.5) * self.grid_width
+
+        # Skip if inside platform.
+        if (platform_min <= bx_center <= platform_max) and (
+          platform_min <= by_center <= platform_max
+        ):
+          continue
+
+        h_noise = rng.uniform(-actual_range / 2, actual_range / 2)
+        total_h = base_h + h_noise
+
+        tilt_x = rng.uniform(-max_tilt, max_tilt)
+        tilt_y = rng.uniform(-max_tilt, max_tilt)
+
+        # Mesh vertices.
+        # Vertical sides: top and bottom x,y are identical.
+        x_min, x_max = bx_center - self.grid_width / 2, bx_center + self.grid_width / 2
+        y_min, y_max = by_center - self.grid_width / 2, by_center + self.grid_width / 2
+
+        verts = []
+        # Bottom verts 0-3 (at -floor_depth)
+        for vx in [x_min, x_max]:
+          for vy in [y_min, y_max]:
+            verts.append([vx, vy, -self.floor_depth])
+        # Top verts 4-7 (tilted)
+        for vx in [x_min, x_max]:
+          for vy in [y_min, y_max]:
+            vz = total_h + tilt_x * (vx - bx_center) + tilt_y * (vy - by_center)
+            verts.append([vx, vy, vz])
+
+        # Faces ccw from outside.
+        # 0:(min,min), 1:(min,max), 2:(max,min), 3:(max,max)
+        # 4-7 are same x,y as 0-3 but at top.
+        # fmt: off
+        faces = [
+          4, 6, 7, 4, 7, 5,  # Top (+z)
+          0, 1, 3, 0, 3, 2,  # Bottom (-z)
+          0, 2, 6, 0, 6, 4,  # Front (-y)
+          1, 5, 7, 1, 7, 3,  # Back (+y)
+          0, 4, 5, 0, 5, 1,  # Left (-x)
+          2, 3, 7, 2, 7, 6,  # Right (+x)
+        ]
+        # fmt: on
+
+        m_name = f"tile_{i}_{j}_{rng.integers(int(1e9))}"
+        mesh = spec.add_mesh(
+          name=m_name,
+          uservert=np.array(verts).flatten().tolist(),
+          userface=np.array(faces).flatten().tolist(),
+        )
+
+        rgba = brand_ramp(_MUJOCO_GREEN, rng.uniform(0.3, 0.7))
+        geom = body.add_geom(
+          type=mujoco.mjtGeom.mjGEOM_MESH,
+          meshname=mesh.name,
+          pos=(0, 0, 0),
+        )
+        geometries.append(TerrainGeometry(geom=geom, color=rgba))
+
+    origin = np.array([self.size[0] / 2, self.size[1] / 2, base_h])
+    return TerrainOutput(origin=origin, geometries=geometries)
+
+
+@dataclass(kw_only=True)
+class BoxNestedRingsTerrainCfg(SubTerrainCfg):
+  num_rings: int = 5
+  ring_width_range: tuple[float, float] = (0.3, 0.6)
+  gap_range: tuple[float, float] = (0.0, 0.2)
+  height_range: tuple[float, float] = (0.1, 0.4)
+  """Min and max ring height, in meters. All rings share a single fixed height
+  taken as the midpoint of this range; difficulty does not scale it."""
+  platform_width: float = 1.0
+  border_width: float = 0.25
+  floor_depth: float = 2.0
+
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    del rng  # Ring layout is deterministic.
+    body = spec.body("terrain")
+    geometries = []
+
+    # Concentric ridges of a single fixed height. Difficulty controls
+    # gap-crossing only: gaps widen and rings narrow, so the terrain reads
+    # consistently across difficulty instead of weakly scaling height.
+    w_min, w_max = self.ring_width_range
+    ring_width = w_max - difficulty * (w_max - w_min)
+
+    ring_height = 0.5 * (self.height_range[0] + self.height_range[1])
+    ring_rgba = brand_ramp(_MUJOCO_BLUE, 0.6)
+
+    border_rgba = darken_rgba(brand_ramp(_MUJOCO_BLUE, 0.0), 0.85)
+
+    if self.border_width > 0.0:
+      # Outer border wall matches the ring height so there is no arbitrary
+      # crossover between the two as difficulty changes.
+      border_h = ring_height
+      border_center = (
+        0.5 * self.size[0],
+        0.5 * self.size[1],
+        (border_h - self.floor_depth) / 2,
+      )
+      border_boxes = make_border(
+        body,
+        self.size,
+        (self.size[0] - 2 * self.border_width, self.size[1] - 2 * self.border_width),
+        border_h + self.floor_depth,
+        border_center,
+      )
+      for b_geom in border_boxes:
+        geometries.append(TerrainGeometry(geom=b_geom, color=border_rgba))
+
+    # Ground floor (deep pit).
+    floor_h = 0.1
+    floor_geom = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_BOX,
+      size=(self.size[0] / 2, self.size[1] / 2, floor_h / 2),
+      pos=(self.size[0] / 2, self.size[1] / 2, -self.floor_depth - floor_h / 2),
+    )
+    geometries.append(TerrainGeometry(geom=floor_geom, color=(0.1, 0.1, 0.1, 1.0)))
+
+    terrain_center = [0.5 * self.size[0], 0.5 * self.size[1], 0.0]
+    terrain_size = (
+      self.size[0] - 2 * self.border_width,
+      self.size[1] - 2 * self.border_width,
+    )
+
+    current_outer_size = list(terrain_size)
+
+    gap_min, gap_max = self.gap_range
+    gap = gap_min + difficulty * (gap_max - gap_min)
+
+    for _ in range(self.num_rings):
+      h = ring_height
+      rgba = ring_rgba
+
+      # Outer dimensions of this ring.
+      ring_outer_size = (
+        current_outer_size[0],
+        current_outer_size[1],
+      )
+
+      # Stop if we get too small.
+      if (
+        ring_outer_size[0] <= self.platform_width
+        or ring_outer_size[1] <= self.platform_width
+      ):
+        break
+
+      # Position each ring segment based on current_outer_size.
+
+      half_h = (h + self.floor_depth) / 2
+      z_pos = (h - self.floor_depth) / 2
+
+      # Four segments for the ring.
+      # Top/Bottom
+      for dy in [-1, 1]:
+        box_pos = (
+          terrain_center[0],
+          terrain_center[1] + dy * (ring_outer_size[1] - ring_width) / 2,
+          z_pos,
+        )
+        box = body.add_geom(
+          type=mujoco.mjtGeom.mjGEOM_BOX,
+          size=(
+            np.maximum(1e-6, ring_outer_size[0] / 2.0),
+            np.maximum(1e-6, ring_width / 2.0),
+            half_h,
+          ),
+          pos=box_pos,
+        )
+        geometries.append(TerrainGeometry(geom=box, color=rgba))
+
+      # Left/Right
+      for dx in [-1, 1]:
+        box_pos = (
+          terrain_center[0] + dx * (ring_outer_size[0] - ring_width) / 2,
+          terrain_center[1],
+          z_pos,
+        )
+        box = body.add_geom(
+          type=mujoco.mjtGeom.mjGEOM_BOX,
+          size=(
+            np.maximum(1e-6, ring_width / 2.0),
+            np.maximum(1e-6, (ring_outer_size[1] - 2 * ring_width) / 2.0),
+            half_h,
+          ),
+          pos=box_pos,
+        )
+        geometries.append(TerrainGeometry(geom=box, color=rgba))
+
+      # Shrink current_outer_size for next ring.
+      current_outer_size[0] -= 2 * (ring_width + gap)
+      current_outer_size[1] -= 2 * (ring_width + gap)
+
+    # Center Platform Column matches the remaining hole exactly.
+    platform_size = (
+      np.maximum(
+        1e-2, current_outer_size[0] + 2 * gap
+      ),  # Fill the ring hole + gap area.
+      np.maximum(1e-2, current_outer_size[1] + 2 * gap),
+    )
+    # Center pad sits flush with the ring height.
+    platform_h = ring_height
+
+    platform_half_h = (platform_h + self.floor_depth) / 2
+    platform_z = (platform_h - self.floor_depth) / 2
+
+    platform_pos = (terrain_center[0], terrain_center[1], platform_z)
+    box = body.add_geom(
+      type=mujoco.mjtGeom.mjGEOM_BOX,
+      size=(platform_size[0] / 2.0, platform_size[1] / 2.0, platform_half_h),
+      pos=platform_pos,
+    )
+    geometries.append(TerrainGeometry(geom=box, color=brand_ramp(_MUJOCO_BLUE, 0.5)))
+
+    origin = np.array([terrain_center[0], terrain_center[1], platform_h])
+    return TerrainOutput(origin=origin, geometries=geometries)
diff --git a/src/mjlab/terrains/terrain_entity.py b/src/mjlab/terrains/terrain_entity.py
new file mode 100644
index 0000000..116b8f4
--- /dev/null
+++ b/src/mjlab/terrains/terrain_entity.py
@@ -0,0 +1,381 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+import mujoco
+import numpy as np
+import torch
+
+from mjlab.entity import Entity, EntityCfg
+from mjlab.terrains.terrain_generator import TerrainGenerator, TerrainGeneratorCfg
+from mjlab.utils import spec_config as spec_cfg
+
+
+def _proportional_counts(num_envs: int, proportions: np.ndarray) -> np.ndarray:
+  """Distribute *num_envs* across buckets proportionally.
+
+  Every bucket gets at least one when ``num_envs >= len(proportions)``. Remaining slots
+  are allocated via the Largest Remainder Method.
+  """
+  n = len(proportions)
+  if num_envs >= n:
+    counts = np.ones(n, dtype=int)
+    remaining = num_envs - n
+  else:
+    counts = np.zeros(n, dtype=int)
+    remaining = num_envs
+  if remaining > 0:
+    ideal = proportions * remaining
+    floor = np.floor(ideal).astype(int)
+    counts += floor
+    leftover = remaining - floor.sum()
+    if leftover > 0:
+      order = np.argsort(-(ideal - floor))
+      counts[order[:leftover]] += 1
+  return counts
+
+
+_DEFAULT_SUN_LIGHT = spec_cfg.LightCfg(
+  name="sun", pos=(0.0, 0.0, 1.5), type="directional"
+)
+
+_DEFAULT_PLANE_TEXTURE = spec_cfg.TextureCfg(
+  name="groundplane",
+  type="2d",
+  builtin="checker",
+  mark="edge",
+  rgb1=(0.2, 0.3, 0.4),
+  rgb2=(0.1, 0.2, 0.3),
+  markrgb=(0.8, 0.8, 0.8),
+  width=300,
+  height=300,
+)
+
+_DEFAULT_PLANE_MATERIAL = spec_cfg.MaterialCfg(
+  name="groundplane",
+  texuniform=True,
+  texrepeat=(4.0, 4.0),
+  reflectance=0.2,
+  texture="groundplane",
+  geom_names_expr=("terrain$",),
+)
+
+
+@dataclass
+class TerrainEntityCfg(EntityCfg):
+  """Configuration for terrain as an entity."""
+
+  terrain_type: Literal["generator", "plane"] = "plane"
+  """Type of terrain to generate. "generator" uses procedural terrain with
+  sub-terrain grid, "plane" creates a flat ground plane."""
+  terrain_generator: TerrainGeneratorCfg | None = None
+  """Configuration for procedural terrain generation. Required when
+  terrain_type is "generator"."""
+  env_spacing: float | None = 2.0
+  """Distance between environment origins when using grid layout. Required for
+  "plane" terrain or when no sub-terrain origins exist."""
+  max_init_terrain_level: int | None = None
+  """Maximum initial difficulty level (row index) for environment placement in
+  curriculum mode. None uses all available rows."""
+  num_envs: int = 1
+  """Number of parallel environments to create. This will get overridden by the
+  scene configuration if specified there."""
+  textures: tuple[spec_cfg.TextureCfg, ...] = field(
+    default_factory=lambda: (_DEFAULT_PLANE_TEXTURE,)
+  )
+  """Textures for the ground plane. Defaults to a checker pattern. Set to
+  ``()`` to disable textures (e.g. when using ``dr.geom_rgba``)."""
+  materials: tuple[spec_cfg.MaterialCfg, ...] = field(
+    default_factory=lambda: (_DEFAULT_PLANE_MATERIAL,)
+  )
+  """Materials for the ground plane. Defaults to the checker material. Set to
+  ``()`` to disable materials (e.g. when using ``dr.geom_rgba``)."""
+  lights: tuple[spec_cfg.LightCfg, ...] = field(
+    default_factory=lambda: (_DEFAULT_SUN_LIGHT,)
+  )
+  """Lights for the scene. Defaults to a directional sun light."""
+  debug_vis: bool = False
+  """Add visualization sites for environment origins, terrain origins, and
+  flat patches. Defaults to False."""
+
+  def build(self) -> TerrainEntity:
+    raise TypeError(
+      "TerrainEntityCfg.build() requires a device argument. "
+      "Use TerrainEntity(cfg, device=...) directly."
+    )
+
+
+class TerrainEntity(Entity):
+  """Terrain entity.
+
+  The terrain is a grid of sub-terrain patches (num_rows x num_cols), each with
+  a spawn origin. When num_envs exceeds the number of patches, environment
+  origins are sampled from the sub-terrain origins.
+
+  .. note::
+    Environment allocation for procedural terrain: Columns (terrain types) are
+    distributed across environments **by proportion** (matching each
+    sub-terrain's ``proportion`` field) when a ``TerrainGeneratorCfg`` is
+    available, or evenly when it is not.  Rows (difficulty levels) are randomly
+    sampled.  This means multiple environments can spawn on the same (row, col)
+    patch, leaving others unoccupied, even when num_envs > num_patches.
+
+  See FAQ: "How does env_origins determine robot layout?"
+  """
+
+  cfg: TerrainEntityCfg
+
+  def __init__(self, cfg: TerrainEntityCfg, device: str) -> None:
+    self._device = device
+    super().__init__(cfg)
+
+  def _build_spec(self) -> None:
+    self._spec = mujoco.MjSpec()
+
+    if self.cfg.terrain_type == "generator":
+      if self.cfg.terrain_generator is None:
+        raise ValueError(
+          "terrain_generator must be specified for terrain_type 'generator'"
+        )
+      terrain_generator = TerrainGenerator(
+        self.cfg.terrain_generator, device=self._device
+      )
+      terrain_generator.compile(self._spec)
+      gen_cfg = self.cfg.terrain_generator
+      proportions = np.array([s.proportion for s in gen_cfg.sub_terrains.values()])
+      proportions = proportions / proportions.sum()
+      self._configure_env_origins(terrain_generator.terrain_origins, proportions)
+      self._flat_patches: dict[str, torch.Tensor] = {
+        name: torch.from_numpy(arr).to(device=self._device, dtype=torch.float)
+        for name, arr in terrain_generator.flat_patches.items()
+      }
+      self._flat_patch_radii: dict[str, float] = dict(
+        terrain_generator.flat_patch_radii
+      )
+    elif self.cfg.terrain_type == "plane":
+      self._import_ground_plane("terrain")
+      self._configure_env_origins()
+      self._flat_patches: dict[str, torch.Tensor] = {}
+      self._flat_patch_radii: dict[str, float] = {}
+    else:
+      raise ValueError(f"Unknown terrain type: {self.cfg.terrain_type}")
+
+    if self.cfg.debug_vis:
+      self._add_env_origin_sites()
+      self._add_terrain_origin_sites()
+      self._add_flat_patch_sites()
+
+  def _add_initial_state_keyframe(self) -> None:
+    pass  # No joints, no keyframe.
+
+  # Terrain-specific properties.
+
+  @property
+  def flat_patches(self) -> dict[str, torch.Tensor]:
+    return self._flat_patches
+
+  @property
+  def flat_patch_radii(self) -> dict[str, float]:
+    return self._flat_patch_radii
+
+  # Terrain origin management.
+
+  def configure_env_origins(
+    self,
+    origins: np.ndarray | torch.Tensor | None = None,
+    proportions: np.ndarray | None = None,
+  ) -> None:
+    """Configure the origins of the environments based on the terrain."""
+    self._configure_env_origins(origins, proportions)
+
+  def _configure_env_origins(
+    self,
+    origins: np.ndarray | torch.Tensor | None = None,
+    proportions: np.ndarray | None = None,
+  ) -> None:
+    if origins is not None:
+      if isinstance(origins, np.ndarray):
+        origins = torch.from_numpy(origins)
+      else:
+        assert isinstance(origins, torch.Tensor)
+      self.terrain_origins = origins.to(self._device, dtype=torch.float)
+      self.env_origins = self._compute_env_origins_curriculum(
+        self.cfg.num_envs, self.terrain_origins, proportions
+      )
+    else:
+      self.terrain_origins = None
+      if self.cfg.env_spacing is None:
+        raise ValueError(
+          "Environment spacing must be specified for configuring grid-like origins."
+        )
+      self.env_origins = self._compute_env_origins_grid(
+        self.cfg.num_envs, self.cfg.env_spacing
+      )
+
+  def update_env_origins(
+    self,
+    env_ids: torch.Tensor,
+    move_up: torch.Tensor,
+    move_down: torch.Tensor,
+  ) -> None:
+    """Update the environment origins based on the terrain levels."""
+    if self.terrain_origins is None:
+      return
+    assert self.env_origins is not None
+    self.terrain_levels[env_ids] += 1 * move_up - 1 * move_down
+    self.terrain_levels[env_ids] = torch.where(
+      self.terrain_levels[env_ids] >= self.max_terrain_level,
+      torch.randint_like(self.terrain_levels[env_ids], self.max_terrain_level),
+      torch.clip(self.terrain_levels[env_ids], 0),
+    )
+    self.env_origins[env_ids] = self.terrain_origins[
+      self.terrain_levels[env_ids], self.terrain_types[env_ids]
+    ]
+
+  def randomize_env_origins(self, env_ids: torch.Tensor) -> None:
+    """Randomize the environment origins to random sub-terrains."""
+    if self.terrain_origins is None:
+      return
+    assert self.env_origins is not None
+    num_rows, num_cols = self.terrain_origins.shape[:2]
+    num_envs = len(env_ids)
+    self.terrain_levels[env_ids] = torch.randint(
+      0, num_rows, (num_envs,), device=self._device
+    )
+    self.terrain_types[env_ids] = torch.randint(
+      0, num_cols, (num_envs,), device=self._device
+    )
+    self.env_origins[env_ids] = self.terrain_origins[
+      self.terrain_levels[env_ids], self.terrain_types[env_ids]
+    ]
+
+  # Private methods.
+
+  def _import_ground_plane(self, name: str) -> None:
+    self._spec.worldbody.add_body(name=name).add_geom(
+      name=name,
+      type=mujoco.mjtGeom.mjGEOM_PLANE,
+      size=(0, 0, 0.01),
+    )
+
+  def _add_env_origin_sites(self) -> None:
+    if self.env_origins is None:
+      return
+    origin_site_radius: float = 0.3
+    origin_site_color = (0.2, 0.6, 0.2, 0.3)
+    if isinstance(self.env_origins, torch.Tensor):
+      env_origins_np = self.env_origins.cpu().numpy()
+    else:
+      env_origins_np = self.env_origins
+    for env_id, origin in enumerate(env_origins_np):
+      self._spec.worldbody.add_site(
+        name=f"env_origin_{env_id}",
+        pos=origin,
+        size=(origin_site_radius,) * 3,
+        type=mujoco.mjtGeom.mjGEOM_SPHERE,
+        rgba=origin_site_color,
+        group=4,
+      )
+
+  def _add_terrain_origin_sites(self) -> None:
+    if self.terrain_origins is None:
+      return
+    if isinstance(self.terrain_origins, torch.Tensor):
+      terrain_origins_np = self.terrain_origins.cpu().numpy()
+    else:
+      terrain_origins_np = self.terrain_origins
+    terrain_origin_site_radius: float = 0.5
+    terrain_origin_site_color = (0.2, 0.2, 0.6, 0.3)
+    num_rows, num_cols = terrain_origins_np.shape[:2]
+    for row in range(num_rows):
+      for col in range(num_cols):
+        origin = terrain_origins_np[row, col]
+        self._spec.worldbody.add_site(
+          name=f"terrain_origin_{row}_{col}",
+          pos=origin,
+          size=(terrain_origin_site_radius,) * 3,
+          type=mujoco.mjtGeom.mjGEOM_SPHERE,
+          rgba=terrain_origin_site_color,
+          group=5,
+        )
+
+  def _add_flat_patch_sites(self) -> None:
+    if not self._flat_patches:
+      return
+    site_thickness = 0.02
+    site_color = (0.9, 0.6, 0.1, 0.1)
+    for name, patches_tensor in self._flat_patches.items():
+      radius = self._flat_patch_radii.get(name, 0.5)
+      patches_np = patches_tensor.cpu().numpy()
+      num_rows, num_cols, num_patches, _ = patches_np.shape
+      for row in range(num_rows):
+        for col in range(num_cols):
+          for p in range(num_patches):
+            pos = patches_np[row, col, p]
+            self._spec.worldbody.add_site(
+              name=f"flat_patch_{name}_{row}_{col}_{p}",
+              pos=pos,
+              size=(radius, radius, site_thickness),
+              type=mujoco.mjtGeom.mjGEOM_BOX,
+              rgba=site_color,
+              group=3,
+            )
+
+  def _compute_env_origins_curriculum(
+    self,
+    num_envs: int,
+    origins: torch.Tensor,
+    proportions: np.ndarray | None = None,
+  ) -> torch.Tensor:
+    """Compute env origins from sub-terrain origins.
+
+    Args:
+      num_envs: Number of environments to place.
+      origins: Sub-terrain origins, shape ``[num_rows, num_cols, 3]``.
+      proportions: Normalized per-column weights. When provided, robots
+        are distributed proportionally (every column gets at least one
+        when ``num_envs >= num_cols``). ``None`` gives even distribution.
+    """
+    num_rows, num_cols = origins.shape[:2]
+    if self.cfg.max_init_terrain_level is None:
+      max_init_level = num_rows - 1
+    else:
+      max_init_level = min(self.cfg.max_init_terrain_level, num_rows - 1)
+    self.max_terrain_level = num_rows
+    self.terrain_levels = torch.randint(
+      0, max_init_level + 1, (num_envs,), device=self._device
+    )
+
+    if proportions is not None and len(proportions) == num_cols:
+      counts = _proportional_counts(num_envs, proportions)
+      self.terrain_types = torch.repeat_interleave(
+        torch.arange(num_cols, device=self._device),
+        torch.from_numpy(counts).to(self._device),
+      )
+    else:
+      self.terrain_types = torch.div(
+        torch.arange(num_envs, device=self._device),
+        (num_envs / num_cols),
+        rounding_mode="floor",
+      ).to(torch.long)
+
+    env_origins = torch.zeros(num_envs, 3, device=self._device)
+    env_origins[:] = origins[self.terrain_levels, self.terrain_types]
+    return env_origins
+
+  def _compute_env_origins_grid(
+    self, num_envs: int, env_spacing: float
+  ) -> torch.Tensor:
+    env_origins = torch.zeros(num_envs, 3, device=self._device)
+    num_rows = np.ceil(num_envs / int(np.sqrt(num_envs)))
+    num_cols = np.ceil(num_envs / num_rows)
+    ii, jj = torch.meshgrid(
+      torch.arange(num_rows, device=self._device),
+      torch.arange(num_cols, device=self._device),
+      indexing="ij",
+    )
+    env_origins[:, 0] = -(ii.flatten()[:num_envs] - (num_rows - 1) / 2) * env_spacing
+    env_origins[:, 1] = (jj.flatten()[:num_envs] - (num_cols - 1) / 2) * env_spacing
+    env_origins[:, 2] = 0.0
+    return env_origins
diff --git a/src/mjlab/terrains/terrain_generator.py b/src/mjlab/terrains/terrain_generator.py
new file mode 100644
index 0000000..a9f55ae
--- /dev/null
+++ b/src/mjlab/terrains/terrain_generator.py
@@ -0,0 +1,373 @@
+from __future__ import annotations
+
+import abc
+from dataclasses import dataclass, field
+from typing import Literal
+
+import mujoco
+import numpy as np
+
+from mjlab.terrains.utils import make_border
+from mjlab.utils.color import RGBA
+
+_DARK_GRAY = (0.2, 0.2, 0.2, 1.0)
+
+
+@dataclass
+class FlatPatchSamplingCfg:
+  """Configuration for sampling flat patches on a heightfield surface."""
+
+  num_patches: int = 10
+  """Number of flat patches to sample per sub-terrain."""
+  patch_radius: float = 0.5
+  """Radius of the circular footprint used to test flatness, in meters."""
+  max_height_diff: float = 0.05
+  """Maximum allowed height variation within the patch footprint, in meters."""
+  x_range: tuple[float, float] = (-1e6, 1e6)
+  """Allowed range of x coordinates for sampled patches, in meters."""
+  y_range: tuple[float, float] = (-1e6, 1e6)
+  """Allowed range of y coordinates for sampled patches, in meters."""
+  z_range: tuple[float, float] = (-1e6, 1e6)
+  """Allowed range of z coordinates (world height) for sampled patches, in meters."""
+  grid_resolution: float | None = None
+  """Resolution of the grid used for flat-patch detection, in meters. When
+  ``None`` (default), the terrain's own ``horizontal_scale`` is used. Set to a
+  smaller value (e.g. 0.025) for finer boundary precision at the cost of a
+  larger intermediate grid."""
+
+
+@dataclass
+class TerrainGeometry:
+  geom: mujoco.MjsGeom | None = None
+  """MuJoCo geometry spec element, or None."""
+  hfield: mujoco.MjsHField | None = None
+  """MuJoCo heightfield spec element, or None."""
+  color: tuple[float, float, float, float] | None = None
+  """RGBA color override for this geometry, or None to use default."""
+
+
+@dataclass
+class TerrainOutput:
+  origin: np.ndarray
+  """Spawn origin position (x, y, z) in the sub-terrain's local frame."""
+  geometries: list[TerrainGeometry]
+  """List of geometry elements comprising this terrain."""
+  flat_patches: dict[str, np.ndarray] | None = None
+  """Named sets of flat patch positions, each an (N, 3) array. None if not configured."""
+
+
+@dataclass
+class SubTerrainCfg(abc.ABC):
+  proportion: float = 1.0
+  """Robot spawning weight for this terrain type.
+
+  In curriculum mode, controls how many robots are spawned on this terrain's
+  column relative to other terrain types. Each terrain type always gets
+  exactly one column; proportion only affects spawning distribution.
+
+  In random mode, controls the sampling probability for each patch.
+  """
+  size: tuple[float, float] = (10.0, 10.0)
+  """Width and length of the terrain patch, in meters."""
+  flat_patch_sampling: dict[str, FlatPatchSamplingCfg] | None = None
+  """Named flat-patch sampling configurations, or None to disable."""
+
+  @abc.abstractmethod
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    """Generate terrain geometry.
+
+    Returns:
+      TerrainOutput containing spawn origin and list of geometries.
+    """
+    raise NotImplementedError
+
+
+@dataclass(kw_only=True)
+class TerrainGeneratorCfg:
+  seed: int | None = None
+  """Random seed for terrain generation. None uses a random seed."""
+  curriculum: bool = False
+  """Controls terrain allocation mode:
+
+  - curriculum=True: Each terrain type gets exactly ONE column. The generator uses
+    ``len(sub_terrains)`` columns regardless of ``num_cols``. Difficulty increases
+    along rows. The ``proportion`` field controls how many robots are spawned per
+    column, not column count.
+
+  - curriculum=False: Every patch is randomly sampled from all terrain types.
+    Proportions control sampling probability. Use this for random variety.
+  """
+  size: tuple[float, float]
+  """Width and length of each sub-terrain patch, in meters."""
+  border_width: float = 0.0
+  """Width of the flat border around the entire terrain grid, in meters."""
+  border_height: float = 1.0
+  """Height of the border wall around the terrain grid, in meters."""
+  num_rows: int = 1
+  """Number of sub-terrain rows in the grid. Represents difficulty levels in
+  curriculum mode. Note: Environments are randomly assigned to rows, so multiple
+  envs can share the same patch."""
+  num_cols: int = 1
+  """Number of sub-terrain columns in the grid.
+
+  In curriculum mode the generator ignores this value and uses one column per terrain
+  type (``len(sub_terrains)``). In random mode it is used as-is."""
+  color_scheme: Literal["height", "random", "none"] = "height"
+  """Coloring strategy for terrain geometry. "height" colors by elevation,
+  "random" assigns random colors, "none" uses uniform gray."""
+  sub_terrains: dict[str, SubTerrainCfg] = field(default_factory=dict)
+  """Named sub-terrain configurations to populate the grid."""
+  difficulty_range: tuple[float, float] = (0.0, 1.0)
+  """Min and max difficulty values used when generating sub-terrains."""
+  add_lights: bool = False
+  """If True, adds a directional light above the terrain grid."""
+
+
+class TerrainGenerator:
+  """Generates procedural terrain grids with configurable difficulty.
+
+  Creates a grid of terrain patches where each patch can be a different
+  terrain type. Supports two modes:
+
+  - **Random mode** (curriculum=False): Every patch independently samples a
+    terrain type weighted by proportions. Results in random variety across
+    all patches.
+
+  - **Curriculum mode** (curriculum=True): Each terrain type gets exactly one column
+    (the generator uses ``len(sub_terrains)`` columns regardless of ``num_cols``).
+    Difficulty increases along rows. The ``proportion`` field controls robot spawning
+    distribution, not column count.
+
+  Terrain types are weighted by proportion and their geometry is generated
+  based on a difficulty value in the configured range. The grid is centered
+  at the world origin. A border can be added around the entire grid along with
+  optional overhead lighting.
+  """
+
+  def __init__(self, cfg: TerrainGeneratorCfg, device: str = "cpu") -> None:
+    if len(cfg.sub_terrains) == 0:
+      raise ValueError("At least one sub_terrain must be specified.")
+
+    self.cfg = cfg
+    self.device = device
+
+    # In curriculum mode, one column per terrain type.
+    if self.cfg.curriculum:
+      self._num_cols = len(self.cfg.sub_terrains)
+    else:
+      self._num_cols = self.cfg.num_cols
+
+    for sub_cfg in self.cfg.sub_terrains.values():
+      sub_cfg.size = self.cfg.size
+
+    if self.cfg.seed is not None:
+      seed = self.cfg.seed
+    else:
+      seed = np.random.randint(0, 10000)
+    self.np_rng = np.random.default_rng(seed)
+
+    self.terrain_origins = np.zeros((self.cfg.num_rows, self._num_cols, 3))
+
+    # Pre-allocate flat patch storage by scanning all sub-terrain configs.
+    self.flat_patches: dict[str, np.ndarray] = {}
+    self.flat_patch_radii: dict[str, float] = {}
+    patch_names: dict[str, int] = {}
+    for sub_cfg in self.cfg.sub_terrains.values():
+      if sub_cfg.flat_patch_sampling is not None:
+        for name, patch_cfg in sub_cfg.flat_patch_sampling.items():
+          if name in patch_names:
+            patch_names[name] = max(patch_names[name], patch_cfg.num_patches)
+          else:
+            patch_names[name] = patch_cfg.num_patches
+          self.flat_patch_radii[name] = max(
+            self.flat_patch_radii.get(name, 0.0), patch_cfg.patch_radius
+          )
+    for name, max_num_patches in patch_names.items():
+      self.flat_patches[name] = np.zeros(
+        (self.cfg.num_rows, self._num_cols, max_num_patches, 3)
+      )
+
+  def compile(self, spec: mujoco.MjSpec) -> None:
+    body = spec.worldbody.add_body(name="terrain")
+
+    if self.cfg.curriculum:
+      self._generate_curriculum_terrains(spec)
+    else:
+      self._generate_random_terrains(spec)
+
+    self._add_terrain_border(spec)
+    self._add_grid_lights(spec)
+
+    counter = 0
+    for geom in body.geoms:
+      if not geom.name:
+        geom.name = f"terrain_{counter}"
+      # Terrain is static (no joints), so body mass is physically meaningless.
+      # Without this, the thousands of dense geoms give the terrain body millions of kg
+      # of mass, which inflates stat.meanmass and makes MuJoCo's force arrow
+      # visualization invisible (arrows scale as force / meanmass).
+      geom.mass = 0
+      counter += 1
+
+  def _generate_random_terrains(self, spec: mujoco.MjSpec) -> None:
+    # Normalize the proportions of the sub-terrains.
+    proportions = np.array(
+      [sub_cfg.proportion for sub_cfg in self.cfg.sub_terrains.values()]
+    )
+    proportions /= np.sum(proportions)
+
+    sub_terrains_cfgs = list(self.cfg.sub_terrains.values())
+
+    # Randomly sample and place sub-terrains in the grid.
+    for index in range(self.cfg.num_rows * self._num_cols):
+      sub_row, sub_col = np.unravel_index(index, (self.cfg.num_rows, self._num_cols))
+      sub_row = int(sub_row)
+      sub_col = int(sub_col)
+
+      # Randomly select a sub-terrain type and difficulty.
+      sub_index = self.np_rng.choice(len(proportions), p=proportions)
+      difficulty = self.np_rng.uniform(*self.cfg.difficulty_range)
+
+      # Calculate the world position for this sub-terrain.
+      world_position = self._get_sub_terrain_position(sub_row, sub_col)
+
+      # Create the terrain mesh and get the spawn origin in world coordinates.
+      spawn_origin = self._create_terrain_geom(
+        spec,
+        world_position,
+        difficulty,
+        sub_terrains_cfgs[sub_index],
+        sub_row,
+        sub_col,
+      )
+
+      # Store the spawn origin for this terrain.
+      self.terrain_origins[sub_row, sub_col] = spawn_origin
+
+  def _generate_curriculum_terrains(self, spec: mujoco.MjSpec) -> None:
+    # One column per terrain type — proportion is only for spawning.
+    sub_terrains_cfgs = list(self.cfg.sub_terrains.values())
+
+    lower, upper = self.cfg.difficulty_range
+    for sub_col in range(self._num_cols):
+      for sub_row in range(self.cfg.num_rows):
+        t = sub_row / max(self.cfg.num_rows - 1, 1)
+        difficulty = lower + (upper - lower) * t
+        world_position = self._get_sub_terrain_position(sub_row, sub_col)
+        spawn_origin = self._create_terrain_geom(
+          spec,
+          world_position,
+          difficulty,
+          sub_terrains_cfgs[sub_col],
+          sub_row,
+          sub_col,
+        )
+        self.terrain_origins[sub_row, sub_col] = spawn_origin
+
+  def _get_sub_terrain_position(self, row: int, col: int) -> np.ndarray:
+    """Get the world position for a sub-terrain at the given grid indices.
+
+    This returns the position of the sub-terrain's corner (not center).
+    The entire grid is centered at the world origin.
+    """
+    # Calculate position relative to grid corner.
+    rel_x = row * self.cfg.size[0]
+    rel_y = col * self.cfg.size[1]
+
+    # Offset to center the entire grid at world origin.
+    grid_offset_x = -self.cfg.num_rows * self.cfg.size[0] * 0.5
+    grid_offset_y = -self._num_cols * self.cfg.size[1] * 0.5
+
+    return np.array([grid_offset_x + rel_x, grid_offset_y + rel_y, 0.0])
+
+  def _create_terrain_geom(
+    self,
+    spec: mujoco.MjSpec,
+    world_position: np.ndarray,
+    difficulty: float,
+    cfg: SubTerrainCfg,
+    sub_row: int,
+    sub_col: int,
+  ) -> np.ndarray:
+    """Create a terrain geometry at the specified world position.
+
+    Args:
+      spec: MuJoCo spec to add geometry to.
+      world_position: World position of the terrain's corner.
+      difficulty: Difficulty parameter for terrain generation.
+      cfg: Sub-terrain configuration.
+      sub_row: Row index in the terrain grid.
+      sub_col: Column index in the terrain grid.
+
+    Returns:
+      The spawn origin in world coordinates.
+    """
+    output = cfg.function(difficulty, spec, self.np_rng)
+    for terrain_geom in output.geometries:
+      if terrain_geom.geom is not None:
+        terrain_geom.geom.pos = np.array(terrain_geom.geom.pos) + world_position
+        if terrain_geom.geom.material is not None:
+          if self.cfg.color_scheme == "height" and terrain_geom.color:
+            terrain_geom.geom.rgba[:] = terrain_geom.color
+          elif self.cfg.color_scheme == "random":
+            terrain_geom.geom.rgba[:3] = self.np_rng.uniform(0.3, 0.8, 3)
+            terrain_geom.geom.rgba[3] = 1.0
+          elif self.cfg.color_scheme == "none":
+            terrain_geom.geom.rgba[:] = (0.5, 0.5, 0.5, 1.0)
+
+    # Collect flat patches into pre-allocated arrays.
+    spawn_origin = output.origin + world_position
+    for name, arr in self.flat_patches.items():
+      if output.flat_patches is not None and name in output.flat_patches:
+        patches = output.flat_patches[name]
+        arr[sub_row, sub_col, : len(patches)] = patches + world_position
+        arr[sub_row, sub_col, len(patches) :] = spawn_origin
+      else:
+        # Sub-terrain didn't produce patches: fill with spawn origin so that
+        # every slot contains a valid position for reset_root_state_from_flat_patches.
+        arr[sub_row, sub_col] = spawn_origin
+
+    return spawn_origin
+
+  def _add_terrain_border(self, spec: mujoco.MjSpec) -> None:
+    if self.cfg.border_width <= 0.0:
+      return
+    body = spec.body("terrain")
+    border_size = (
+      self.cfg.num_rows * self.cfg.size[0] + 2 * self.cfg.border_width,
+      self._num_cols * self.cfg.size[1] + 2 * self.cfg.border_width,
+    )
+    inner_size = (
+      self.cfg.num_rows * self.cfg.size[0],
+      self._num_cols * self.cfg.size[1],
+    )
+    # Border should be centered at origin since the terrain grid is centered.
+    border_center = (0, 0, -self.cfg.border_height / 2)
+    boxes = make_border(
+      body,
+      border_size,
+      inner_size,
+      height=abs(self.cfg.border_height),
+      position=border_center,
+    )
+    for box in boxes:
+      if self.cfg.color_scheme == "random":
+        box.rgba = RGBA.random(self.np_rng, alpha=1.0)
+      else:
+        box.rgba = _DARK_GRAY
+
+  def _add_grid_lights(self, spec: mujoco.MjSpec) -> None:
+    if not self.cfg.add_lights:
+      return
+
+    total_width = self.cfg.size[0] * self.cfg.num_rows
+    total_height = self.cfg.size[1] * self._num_cols
+    light_height = max(total_width, total_height) * 0.6
+
+    spec.body("terrain").add_light(
+      pos=(0, 0, light_height),
+      type=mujoco.mjtLightType.mjLIGHT_DIRECTIONAL,
+      dir=(0, 0, -1),
+    )
diff --git a/src/mjlab/terrains/utils.py b/src/mjlab/terrains/utils.py
new file mode 100644
index 0000000..ff48515
--- /dev/null
+++ b/src/mjlab/terrains/utils.py
@@ -0,0 +1,210 @@
+"""Utility functions for terrain generation.
+
+References:
+  IsaacLab terrain utilities:
+  https://github.com/isaac-sim/IsaacLab/blob/main/source/isaaclab/isaaclab/terrains/trimesh/utils.py
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import mujoco
+import numpy as np
+from scipy import ndimage
+
+if TYPE_CHECKING:
+  from mjlab.terrains.terrain_generator import FlatPatchSamplingCfg
+
+
+def find_flat_patches_from_heightfield(
+  heights: np.ndarray,
+  horizontal_scale: float,
+  z_offset: float,
+  cfg: FlatPatchSamplingCfg,
+  rng: np.random.Generator,
+) -> np.ndarray:
+  """Find flat patches on a heightfield surface using morphological filtering.
+
+  Slides a circular footprint over every pixel and keeps those where the
+  height variation is within tolerance. Randomly samples from the valid set.
+
+  Args:
+    heights: 2D array of physical heights (meters), shape (num_rows, num_cols).
+    horizontal_scale: Physical size of each pixel in meters.
+    z_offset: Vertical offset of the heightfield origin.
+    cfg: Flat patch sampling configuration.
+    rng: Random number generator.
+
+  Returns:
+    Array of shape (num_patches, 3) with (x, y, z) positions in sub-terrain
+    local frame.
+  """
+  # Optionally upsample to a finer grid for higher-precision boundary detection.
+  if cfg.grid_resolution is not None and cfg.grid_resolution < horizontal_scale:
+    zoom_factor = horizontal_scale / cfg.grid_resolution
+    heights = np.asarray(ndimage.zoom(heights, zoom_factor, order=1))
+    horizontal_scale = cfg.grid_resolution
+
+  num_rows, num_cols = heights.shape
+
+  # Build circular footprint.
+  radius_pixels = int(np.ceil(cfg.patch_radius / horizontal_scale))
+  y_grid, x_grid = np.ogrid[
+    -radius_pixels : radius_pixels + 1, -radius_pixels : radius_pixels + 1
+  ]
+  footprint = (x_grid**2 + y_grid**2) <= radius_pixels**2
+
+  # Morphological max/min filter to find height variation within footprint.
+  # Use constant padding so edge pixels where the footprint extends outside
+  # the data are not incorrectly marked flat (default 'reflect' hides edges).
+  max_h = ndimage.maximum_filter(
+    heights, footprint=footprint, mode="constant", cval=-np.inf
+  )
+  min_h = ndimage.minimum_filter(
+    heights, footprint=footprint, mode="constant", cval=np.inf
+  )
+  valid_mask = (max_h - min_h) <= cfg.max_height_diff
+
+  # Exclude pixels whose footprint would extend outside the array. This
+  # ensures the full patch circle lies within the heightfield bounds.
+  valid_mask[:radius_pixels, :] = False
+  valid_mask[-radius_pixels:, :] = False
+  valid_mask[:, :radius_pixels] = False
+  valid_mask[:, -radius_pixels:] = False
+
+  # Apply spatial range constraints.
+  # MuJoCo hfield convention: columns map to the x-axis, rows map to the
+  # y-axis (see engine_ray.c vertex: {dx*c - size[0], dy*r - size[1], ...}).
+  x_coords = np.arange(num_cols) * horizontal_scale
+  y_coords = np.arange(num_rows) * horizontal_scale
+
+  x_valid = (x_coords >= cfg.x_range[0]) & (x_coords <= cfg.x_range[1])
+  y_valid = (y_coords >= cfg.y_range[0]) & (y_coords <= cfg.y_range[1])
+  valid_mask &= y_valid[:, None] & x_valid[None, :]
+
+  # Apply z range constraint.
+  z_values = heights + z_offset
+  z_valid = (z_values >= cfg.z_range[0]) & (z_values <= cfg.z_range[1])
+  valid_mask &= z_valid
+
+  valid_indices = np.argwhere(valid_mask)
+
+  if len(valid_indices) == 0:
+    # Fallback: return sub-terrain center repeated.
+    center_x = num_cols * horizontal_scale / 2.0
+    center_y = num_rows * horizontal_scale / 2.0
+    center_row = min(num_rows // 2, num_rows - 1)
+    center_col = min(num_cols // 2, num_cols - 1)
+    center_z = heights[center_row, center_col] + z_offset
+    return np.tile([center_x, center_y, center_z], (cfg.num_patches, 1))
+
+  replace = len(valid_indices) < cfg.num_patches
+  chosen = rng.choice(len(valid_indices), size=cfg.num_patches, replace=replace)
+  selected = valid_indices[chosen]
+
+  x = selected[:, 1] * horizontal_scale
+  y = selected[:, 0] * horizontal_scale
+  z = heights[selected[:, 0], selected[:, 1]] + z_offset
+
+  return np.stack([x, y, z], axis=-1)
+
+
+def make_plane(
+  body: mujoco.MjsBody,
+  size: tuple[float, float],
+  height: float,
+  center_zero: bool = True,
+  plane_thickness: float = 1.0,
+):
+  """Create finite plane using box geometry.
+
+  Uses box instead of MuJoCo plane to avoid infinite extent in terrain grids.
+  Thickness prevents penetration issues.
+  """
+  if center_zero:
+    pos = (0, 0, height - plane_thickness / 2.0)
+  else:
+    pos = (size[0] / 2.0, size[1] / 2.0, height - plane_thickness / 2.0)
+
+  box = body.add_geom(
+    type=mujoco.mjtGeom.mjGEOM_BOX,
+    size=(size[0] / 2.0, size[1] / 2.0, plane_thickness / 2.0),
+    pos=pos,
+  )
+  return [box]
+
+
+def make_border(
+  body: mujoco.MjsBody,
+  size: tuple[float, float],
+  inner_size: tuple[float, float],
+  height: float,
+  position: tuple[float, float, float],
+):
+  """Create rectangular border using four box geometries.
+
+  Returns top, bottom, left, right boxes forming a hollow rectangle.
+  """
+  boxes = []
+
+  thickness_x = (size[0] - inner_size[0]) / 2.0
+  thickness_y = (size[1] - inner_size[1]) / 2.0
+
+  box_dims = (size[0], thickness_y, height)
+
+  # Top.
+  box_pos = (
+    position[0],
+    position[1] + inner_size[1] / 2.0 + thickness_y / 2.0,
+    position[2],
+  )
+  box = body.add_geom(
+    type=mujoco.mjtGeom.mjGEOM_BOX,
+    size=(box_dims[0] / 2.0, box_dims[1] / 2.0, box_dims[2] / 2.0),
+    pos=box_pos,
+  )
+  boxes.append(box)
+
+  # Bottom.
+  box_pos = (
+    position[0],
+    position[1] - inner_size[1] / 2.0 - thickness_y / 2.0,
+    position[2],
+  )
+  box = body.add_geom(
+    type=mujoco.mjtGeom.mjGEOM_BOX,
+    size=(box_dims[0] / 2.0, box_dims[1] / 2.0, box_dims[2] / 2.0),
+    pos=box_pos,
+  )
+  boxes.append(box)
+
+  box_dims = (thickness_x, inner_size[1], height)
+
+  # Left.
+  box_pos = (
+    position[0] - inner_size[0] / 2.0 - thickness_x / 2.0,
+    position[1],
+    position[2],
+  )
+  box = body.add_geom(
+    type=mujoco.mjtGeom.mjGEOM_BOX,
+    size=(box_dims[0] / 2.0, box_dims[1] / 2.0, box_dims[2] / 2.0),
+    pos=box_pos,
+  )
+  boxes.append(box)
+
+  # Right.
+  box_pos = (
+    position[0] + inner_size[0] / 2.0 + thickness_x / 2.0,
+    position[1],
+    position[2],
+  )
+  box = body.add_geom(
+    type=mujoco.mjtGeom.mjGEOM_BOX,
+    size=(box_dims[0] / 2.0, box_dims[1] / 2.0, box_dims[2] / 2.0),
+    pos=box_pos,
+  )
+  boxes.append(box)
+
+  return boxes
diff --git a/src/mjlab/utils/__init__.py b/src/mjlab/utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/mjlab/utils/actuator.py b/src/mjlab/utils/actuator.py
new file mode 100644
index 0000000..465170a
--- /dev/null
+++ b/src/mjlab/utils/actuator.py
@@ -0,0 +1,80 @@
+"""Electric actuator utilities."""
+
+import math
+from dataclasses import dataclass
+from typing import NamedTuple
+
+
+@dataclass(frozen=True)
+class ElectricActuator:
+  """Electric actuator parameters."""
+
+  reflected_inertia: float
+  velocity_limit: float
+  effort_limit: float
+
+
+def reflected_inertia(
+  rotor_inertia: float,
+  gear_ratio: float,
+) -> float:
+  """Compute reflected inertia of a single-stage gearbox."""
+  return rotor_inertia * gear_ratio**2
+
+
+def reflected_inertia_from_two_stage_planetary(
+  rotor_inertia: tuple[float, float, float],
+  gear_ratio: tuple[float, float, float],
+) -> float:
+  """Compute reflected inertia of a two-stage planetary gearbox."""
+  assert gear_ratio[0] == 1
+  r1 = rotor_inertia[0] * (gear_ratio[1] * gear_ratio[2]) ** 2
+  r2 = rotor_inertia[1] * gear_ratio[2] ** 2
+  r3 = rotor_inertia[2]
+  return r1 + r2 + r3
+
+
+def rpm_to_rad(rpm: float) -> float:
+  """Convert revolutions per minute to radians per second."""
+  return (rpm * 2 * math.pi) / 60
+
+
+class LinearJointProperties(NamedTuple):
+  """Linear joint properties reflected from a rotary actuator."""
+
+  armature: float  # kg
+  velocity_limit: float  # m/s
+  effort_limit: float  # N
+
+
+def reflect_rotary_to_linear(
+  armature_rotary: float,
+  velocity_limit_rotary: float,
+  effort_limit_rotary: float,
+  transmission_ratio: float,
+) -> LinearJointProperties:
+  """Reflect rotary motor properties through a transmission to linear joint properties.
+
+  Converts motor specs from rotary coordinates (rad, rad/s, Nm) to equivalent linear
+  properties (kg, m/s, N) for simulation. Uses energy and power equivalence:
+    - Linear mass: m = I / r²
+    - Linear velocity: v = r · ω
+    - Linear force: F = τ / r
+  where r is the transmission ratio [m/rad].
+
+  Args:
+    armature_rotary: Reflected inertia at motor output [kg⋅m²].
+    velocity_limit_rotary: Maximum angular velocity [rad/s].
+    effort_limit_rotary: Maximum torque [Nm].
+    transmission_ratio: Linear displacement per radian [m/rad].
+
+  Returns:
+    Linear joint properties (armature [kg], velocity_limit [m/s], effort_limit [N])
+  """
+  armature_linear = armature_rotary / (transmission_ratio**2)
+  velocity_limit_linear = velocity_limit_rotary * transmission_ratio
+  effort_limit_linear = effort_limit_rotary / transmission_ratio
+
+  return LinearJointProperties(
+    armature_linear, velocity_limit_linear, effort_limit_linear
+  )
diff --git a/src/mjlab/utils/buffers/__init__.py b/src/mjlab/utils/buffers/__init__.py
new file mode 100644
index 0000000..034cf3b
--- /dev/null
+++ b/src/mjlab/utils/buffers/__init__.py
@@ -0,0 +1,4 @@
+"""Buffer utilities."""
+
+from mjlab.utils.buffers.circular_buffer import CircularBuffer as CircularBuffer
+from mjlab.utils.buffers.delay_buffer import DelayBuffer as DelayBuffer
diff --git a/src/mjlab/utils/buffers/circular_buffer.py b/src/mjlab/utils/buffers/circular_buffer.py
new file mode 100644
index 0000000..50746d7
--- /dev/null
+++ b/src/mjlab/utils/buffers/circular_buffer.py
@@ -0,0 +1,267 @@
+"""Circular buffer for storing a history of batched tensor data.
+
+Understanding Dimensions
+========================
+
+Internal storage shape: (max_len, batch_size, ...)
+                         ↑         ↑
+                         time      environments
+                         axis      axis
+
+External view (buffer property): (batch_size, max_len, ...)
+                                  ↑           ↑
+                                  environments time
+                                  axis        axis
+
+Why different?
+  - Internal: time-first for clean API (self._buffer[pointer] = data)
+  - External: batch-first for typical use (iterate over environments)
+
+Backfill Behavior
+=================
+
+When you first append to a new or reset batch row, that first value is copied
+to ALL history slots for that row:
+
+  buffer = CircularBuffer(max_len=3, batch_size=2, device="cpu")
+  buffer.append(torch.tensor([[5.0], [10.0]]))
+
+  # buffer.buffer contains (shape: 2, 3, 1):
+  # Batch 0: [5.0, 5.0, 5.0]   <- all slots filled with first value
+  # Batch 1: [10.0, 10.0, 10.0] <- all slots filled with first value
+
+Why backfill?
+  You always have valid data. If training expects 3 frames of history, you
+  don't want garbage/zeros for the first 2 timesteps.
+
+Per-Batch Reset
+===============
+
+Reset affects specific batch rows. The circular pointer advances globally, but
+reset rows get "first-append" treatment on their next write:
+
+  buffer = CircularBuffer(max_len=3, batch_size=3, device="cpu")
+
+  buffer.append(torch.tensor([[1.0], [10.0], [100.0]]))   # t0
+  buffer.append(torch.tensor([[2.0], [20.0], [200.0]]))   # t1
+  buffer.append(torch.tensor([[3.0], [30.0], [300.0]]))   # t2
+
+  # buffer.buffer:
+  # Batch 0: [1.0, 2.0, 3.0]
+  # Batch 1: [10.0, 20.0, 30.0]
+  # Batch 2: [100.0, 200.0, 300.0]
+
+  buffer.reset(batch_ids=[1])  # Reset only batch 1
+
+  # buffer.buffer after reset:
+  # Batch 0: [1.0, 2.0, 3.0]       <- unchanged
+  # Batch 1: [0.0, 0.0, 0.0]       <- zeroed
+  # Batch 2: [100.0, 200.0, 300.0] <- unchanged
+
+  # current_length: [3, 0, 3]  <- batch 1 has 0 valid frames
+
+  buffer.append(torch.tensor([[4.0], [99.0], [400.0]]))  # t3
+
+  # buffer.buffer after append:
+  # Batch 0: [2.0, 3.0, 4.0]        <- oldest overwritten (normal)
+  # Batch 1: [99.0, 99.0, 99.0]     <- BACKFILLED with 99.0
+  # Batch 2: [200.0, 300.0, 400.0]  <- oldest overwritten (normal)
+
+Key insight:
+  Reset only affects specific batch rows. The pointer keeps advancing for
+  everyone, but reset rows get backfilled on their next append.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import torch
+
+
+class CircularBuffer:
+  """Fixed-length circular buffer for batched tensor history.
+
+  Stores history with shape (max_len, batch_size, ...) internally.
+  The `buffer` property returns chronologically ordered data (oldest to newest)
+  with shape (batch_size, max_len, ...).
+
+  Storage and Retrieval
+  ---------------------
+  Internal storage (circular):
+    ┌─────┬─────┬─────┐
+    │  2  │  3  │  1  │  <- pointer at index 1 (newest = 3)
+    └─────┴─────┴─────┘
+     idx:0  idx:1  idx:2
+
+  buffer property returns (chronological, oldest→newest):
+    ┌─────┬─────┬─────┐
+    │  1  │  2  │  3  │
+    └─────┴─────┴─────┘
+
+  LIFO Retrieval via __getitem__
+  -------------------------------
+  Given buffer with [1, 2, 3] (oldest to newest):
+    buffer[lag=0] -> 3  (most recent)
+    buffer[lag=1] -> 2  (one step back)
+    buffer[lag=2] -> 1  (oldest)
+
+  Per-Batch Reset
+  ---------------
+  After reset(batch_ids=[1]):
+    Batch 0: [1, 2, 3]  (unchanged)
+    Batch 1: [0, 0, 0]  (zeroed, current_length=0)
+    Batch 2: [1, 2, 3]  (unchanged)
+
+  Next append backfills reset rows with first value.
+
+  Args:
+    max_len: Maximum number of historical frames to retain.
+    batch_size: Size of the batch dimension.
+    device: Torch device for storage.
+  """
+
+  def __init__(self, max_len: int, batch_size: int, device: str) -> None:
+    if max_len < 1:
+      raise ValueError(f"Buffer size must be >= 1, got {max_len}")
+
+    self._max_len = max_len
+    self._batch_size = batch_size
+    self._device = device
+    self._pointer: int = -1
+    self._buffer: torch.Tensor | None = None
+    self._all_indices = torch.arange(batch_size, device=device)
+    self._num_pushes = torch.zeros(batch_size, dtype=torch.long, device=device)
+    self._max_len_tensor = torch.full(
+      (batch_size,), max_len, dtype=torch.long, device=device
+    )
+
+  @property
+  def batch_size(self) -> int:
+    return self._batch_size
+
+  @property
+  def device(self) -> str:
+    return self._device
+
+  @property
+  def max_length(self) -> int:
+    return self._max_len
+
+  @property
+  def current_length(self) -> torch.Tensor:
+    """Per-batch count of valid frames. Shape: (batch_size,)."""
+    return torch.minimum(self._num_pushes, self._max_len_tensor)
+
+  @property
+  def is_initialized(self) -> bool:
+    """Check if the buffer has been initialized with at least one append."""
+    return self._buffer is not None
+
+  @property
+  def buffer(self) -> torch.Tensor:
+    """History in chronological order (oldest to newest).
+
+    Returns:
+      Tensor of shape (batch_size, max_len, ...) where index 0 is oldest
+      and index -1 is newest.
+    """
+    if self._buffer is None:
+      raise RuntimeError("Buffer not initialized. Call append() first.")
+
+    start = (self._pointer + 1) % self._max_len
+    idx = (torch.arange(self._max_len, device=self._device) + start) % self._max_len
+    buf = self._buffer.index_select(0, idx)  # (max_len, batch, ...)
+    return buf.transpose(0, 1)  # (batch, max_len, ...)
+
+  def reset(self, batch_ids: Sequence[int] | torch.Tensor | None = None) -> None:
+    """Zero out values and counters for specified batch rows.
+
+    Args:
+      batch_ids: Batch indices to reset, or None to reset all.
+    """
+    ids: Sequence[int] | torch.Tensor | slice = (
+      slice(None) if batch_ids is None else batch_ids
+    )
+    self._num_pushes[ids] = 0
+    if self._buffer is not None:
+      self._buffer[:, ids] = 0.0
+
+  def backfill(self, data: torch.Tensor, batch_ids: torch.Tensor) -> None:
+    """Fill the given rows' entire history with one frame, without advancing time.
+
+    Unlike append, the global pointer does not move and other rows are
+    untouched. Used after a partial reset: the reset rows get their first
+    post-reset frame in every slot (the same backfill their next append would
+    apply) while the remaining rows keep their history intact.
+
+    Args:
+      data: Tensor of shape (batch_size, ...); only rows at batch_ids are read.
+      batch_ids: Batch indices to backfill.
+    """
+    if data.shape[0] != self._batch_size:
+      raise ValueError(f"Expected batch size {self._batch_size}, got {data.shape[0]}")
+    if self._buffer is None:
+      raise RuntimeError("Buffer not initialized. Call append() first.")
+
+    data = data.to(self._device)
+    self._buffer[:, batch_ids] = data[batch_ids].unsqueeze(0)
+    self._num_pushes[batch_ids] = 1
+
+  def append(self, data: torch.Tensor) -> None:
+    """Append a new frame for all batch elements.
+
+    Args:
+      data: Tensor of shape (batch_size, ...).
+    """
+    if data.shape[0] != self._batch_size:
+      raise ValueError(f"Expected batch size {self._batch_size}, got {data.shape[0]}")
+
+    data = data.to(self._device)
+
+    if self._buffer is None:
+      self._pointer = -1
+      self._buffer = torch.empty(
+        (self._max_len, *data.shape), dtype=data.dtype, device=self._device
+      )
+
+    self._pointer = (self._pointer + 1) % self._max_len
+    self._buffer[self._pointer] = data
+
+    # Backfill entire history with first frame for newly initialized batches.
+    # The condition and data are reshaped to broadcast against the buffer's
+    # (max_len, batch_size, ...) shape for data of any rank.
+    is_first_push = self._num_pushes == 0
+    condition = is_first_push.view(1, self._batch_size, *([1] * (data.ndim - 1)))
+    torch.where(condition, data.unsqueeze(0), self._buffer, out=self._buffer)
+
+    self._num_pushes += 1
+
+  def __getitem__(self, key: torch.Tensor | int) -> torch.Tensor:
+    """Retrieve lagged frames per batch (LIFO).
+
+    Args:
+      key: Per-batch lags (Tensor) or shared lag (int). Shape (batch_size,) or scalar.
+    """
+    if self._buffer is None:
+      raise RuntimeError("Buffer not initialized. Call append() first.")
+
+    if isinstance(key, int):
+      key = torch.full((self._batch_size,), key, dtype=torch.long, device=self._device)
+    else:
+      if key.ndim == 0:
+        key = key.expand(self._batch_size)
+      key = key.to(device=self._device, dtype=torch.long)
+
+    if key.numel() != self._batch_size:
+      raise ValueError(f"Expected {self._batch_size} lags, got {key.numel()}")
+
+    # Clamp to the oldest retained frame: without the max_len bound, a lag
+    # beyond the buffer length would wrap around to a newer frame once
+    # num_pushes exceeds max_len.
+    pushes = self._num_pushes.clamp_min(1)
+    max_lag = torch.minimum(pushes, self._max_len_tensor) - 1
+    valid = torch.minimum(key, max_lag).clamp_min(0)
+
+    idx = torch.remainder(self._pointer - valid, self._max_len)
+    return self._buffer[idx, self._all_indices]
diff --git a/src/mjlab/utils/buffers/delay_buffer.py b/src/mjlab/utils/buffers/delay_buffer.py
new file mode 100644
index 0000000..6c4b824
--- /dev/null
+++ b/src/mjlab/utils/buffers/delay_buffer.py
@@ -0,0 +1,331 @@
+"""Delay buffer for stochastically delayed observations."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import torch
+
+from mjlab.utils.buffers import CircularBuffer
+
+
+class DelayBuffer:
+  """Serve stochastically delayed observations from a rolling history.
+
+  Wraps a CircularBuffer to simulate observation delays by returning frames from T-lag
+  timesteps ago, where lag is sampled from [min_lag, max_lag].
+
+  Core Behavior
+  =============
+
+  At each timestep:
+    1. Append new observation to history
+    2. Sample or hold lag value (0 = no delay, 3 = 3 timesteps old)
+    3. Return observation from T-lag
+
+  Example with lag=2:
+    t=0: append obs_0 → return obs_0 (not enough history)
+    t=1: append obs_1 → return obs_0 (clamped to available history)
+    t=2: append obs_2 → return obs_0 (lag=2, so T-2 = 0)
+    t=3: append obs_3 → return obs_1 (lag=2, so T-2 = 1)
+
+  Lag Update Policy
+  =================
+
+  Lags can be refreshed every step or periodically:
+
+    **Every-step updates (update_period=0)**
+      Each timestep may sample a new lag (subject to hold_prob).
+
+    **Periodic updates (update_period=N)**
+      Lags refresh only every N steps per environment:
+        if (step_count + phase_offset) % N == 0:
+            sample new lag
+        else:
+            keep previous lag
+
+    **Staggered updates (per_env_phase=True)**
+      Each environment gets a random phase_offset ∈ [0, N), causing
+      lag updates to occur on different timesteps:
+        Env 0: updates at t=0, N, 2N, ...
+        Env 1: updates at t=3, N+3, 2N+3, ...
+        Env 2: updates at t=7, N+7, 2N+7, ...
+
+    **Hold probability (hold_prob=0.2)**
+      Even when an update would occur, keep previous lag with 20% chance.
+      Creates temporal correlation in delay patterns.
+
+  Per-Environment vs Shared Lags
+  ==============================
+
+    **per_env=True** (default)
+      Each environment has independent lag:
+        Batch 0: lag=1 → returns obs from t-1
+        Batch 1: lag=3 → returns obs from t-3
+        Batch 2: lag=0 → returns current obs
+
+    **per_env=False**
+      All environments share one sampled lag:
+        All batches: lag=2 → all return obs from t-2
+
+  Reset Behavior
+  ==============
+
+    reset(batch_ids=[1]) clears history for specified environments:
+      - Sets lag and step counter to zero
+      - Clears circular buffer for those rows
+      - Next append backfills their history with first new value
+      - Until that append, compute() returns zeros for reset rows
+
+  Args:
+    min_lag (int, optional): Minimum lag (inclusive). Must be >= 0.
+    max_lag (int, optional): Maximum lag (inclusive). Must be >= `min_lag`.
+    batch_size (int, optional): Number of parallel environments (leading
+      dimension of inputs).
+    device (str, optional): Torch device for storage and RNG.
+    per_env (bool, optional): If True, sample a separate lag per environment;
+      otherwise sample one lag and share it across environments.
+    hold_prob (float, optional): Probability in `[0.0, 1.0]` to keep the previous
+      lag when an update would occur. Creates temporal correlation in delays.
+    update_period (int, optional): If > 0, refresh lags every N steps per
+      environment; if 0, consider updating every step.
+    per_env_phase (bool, optional): If True and `update_period > 0`, each
+      environment uses a different phase offset in `[0, update_period)`, causing
+      staggered refresh steps across the batch.
+    generator (torch.Generator | None, optional): Optional RNG for sampling lags.
+
+  Examples:
+    Constant delay (lag = 2):
+      >>> buf = DelayBuffer(min_lag=2, max_lag=2, batch_size=4)
+      >>> buf.append(obs)                # obs.shape == (4, ...)
+      >>> delayed = buf.compute()        # delayed[t] = obs[t-2]
+
+    Stochastic delay (uniform 0-3):
+      >>> buf = DelayBuffer(min_lag=0, max_lag=3, batch_size=4)
+      >>> buf.append(obs)
+      >>> delayed = buf.compute()        # per-env lag sampled in {0,1,2,3}
+
+    Periodic updates with staggering:
+      >>> buf = DelayBuffer(
+      ...     min_lag=1, max_lag=5, batch_size=8,
+      ...     update_period=10,           # refresh every 10 steps
+      ...     per_env_phase=True,         # stagger across envs
+      ...     hold_prob=0.2               # 20% chance to hold lag
+      ... )
+      >>> # Env 0 refreshes at t=0,10,20,...
+      >>> # Env 1 refreshes at t=3,13,23,... (random offset)
+      >>> # But each refresh has 20% chance to keep previous lag
+  """
+
+  def __init__(
+    self,
+    min_lag: int = 0,
+    max_lag: int = 3,
+    batch_size: int = 1,
+    device: str = "cpu",
+    per_env: bool = True,
+    hold_prob: float = 0.0,
+    update_period: int = 0,
+    per_env_phase: bool = True,
+    generator: torch.Generator | None = None,
+  ) -> None:
+    if min_lag < 0:
+      raise ValueError(f"min_lag must be >= 0, got {min_lag}")
+    if max_lag < min_lag:
+      raise ValueError(f"max_lag ({max_lag}) must be >= min_lag ({min_lag})")
+    if not 0.0 <= hold_prob <= 1.0:
+      raise ValueError(f"hold_prob must be in [0, 1], got {hold_prob}")
+    if update_period < 0:
+      raise ValueError(f"update_period must be >= 0, got {update_period}")
+
+    self.min_lag = min_lag
+    self.max_lag = max_lag
+    self.batch_size = batch_size
+    self.device = device
+    self.per_env = per_env
+    self.hold_prob = hold_prob
+    self.update_period = update_period
+    self.per_env_phase = per_env_phase
+    self.generator = generator
+
+    buffer_size = max_lag + 1 if max_lag > 0 else 1
+    self._buffer = CircularBuffer(
+      max_len=buffer_size, batch_size=batch_size, device=device
+    )
+    self._current_lags = torch.zeros(batch_size, dtype=torch.long, device=device)
+    self._step_count = torch.zeros(batch_size, dtype=torch.long, device=device)
+
+    if update_period > 0 and per_env_phase:
+      self._phase_offsets = torch.randint(
+        0,
+        update_period,
+        (batch_size,),
+        dtype=torch.long,
+        device=device,
+        generator=generator,
+      )
+    else:
+      self._phase_offsets = torch.zeros(batch_size, dtype=torch.long, device=device)
+
+  @property
+  def is_initialized(self) -> bool:
+    """Check if buffer has been initialized with at least one append."""
+    return self._buffer.is_initialized
+
+  @property
+  def current_lags(self) -> torch.Tensor:
+    """Current lag per environment. Shape: (batch_size,)."""
+    return self._current_lags
+
+  def set_lags(
+    self,
+    lags: torch.Tensor,
+    batch_ids: Sequence[int] | torch.Tensor | slice | None = None,
+  ) -> None:
+    """Set lag values for specified environments.
+
+    Args:
+      lags: Lag values to set. Shape: (num_batch_ids,) or scalar.
+      batch_ids: Batch indices to set, or None to set all.
+    """
+    idx = slice(None) if batch_ids is None else batch_ids
+    self._current_lags[idx] = lags.clamp(self.min_lag, self.max_lag)
+
+  def reset(
+    self, batch_ids: Sequence[int] | torch.Tensor | slice | None = None
+  ) -> None:
+    """Reset specified environments to initial state.
+
+    Args:
+      batch_ids: Batch indices to reset, or None to reset all.
+    """
+    if isinstance(batch_ids, slice):
+      indices = range(*batch_ids.indices(self.batch_size))
+      batch_ids = list(indices)
+
+    self._buffer.reset(batch_ids=batch_ids)
+    idx = slice(None) if batch_ids is None else batch_ids
+    self._current_lags[idx] = 0
+    self._step_count[idx] = 0
+    if self.update_period > 0 and self.per_env_phase:
+      new_phases = torch.randint(
+        0,
+        self.update_period,
+        (self.batch_size,),
+        dtype=torch.long,
+        device=self.device,
+        generator=self.generator,
+      )
+      self._phase_offsets[idx] = new_phases[idx]
+
+  def append(self, data: torch.Tensor) -> None:
+    """Append new observation to buffer.
+
+    Args:
+      data: Observation tensor of shape (batch_size, ...).
+    """
+    self._buffer.append(data)
+
+  def backfill(self, data: torch.Tensor, batch_ids: torch.Tensor) -> None:
+    """Backfill the given rows with one frame, without advancing time.
+
+    Used after a partial reset: the reset rows (whose lags and step counters
+    were just zeroed by reset) get their first post-reset frame while the
+    remaining rows keep their history, lags, and update schedule intact.
+
+    Args:
+      data: Tensor of shape (batch_size, ...); only rows at batch_ids are read.
+      batch_ids: Batch indices to backfill.
+    """
+    self._buffer.backfill(data, batch_ids)
+
+  def compute(self) -> torch.Tensor:
+    """Compute delayed observation for current step.
+
+    Advances the lag update schedule, then returns the delayed observation.
+
+    Returns:
+      Delayed observation with shape (batch_size, ...).
+    """
+    if not self.is_initialized:
+      raise RuntimeError("Buffer not initialized. Call append() first.")
+
+    self._update_lags()
+    return self.peek()
+
+  def peek(self) -> torch.Tensor:
+    """Return the delayed observation using current lags, without advancing.
+
+    Unlike compute, this neither steps the update schedule nor resamples lags,
+    so it is safe to call outside the once-per-step cadence.
+
+    Returns:
+      Delayed observation with shape (batch_size, ...).
+    """
+    if not self.is_initialized:
+      raise RuntimeError("Buffer not initialized. Call append() first.")
+
+    # Clamp lags to valid range [0, buffer_length - 1].
+    # Buffer may not be full yet (e.g., only 2 frames but sampled lag=3).
+    valid_lags = torch.minimum(self._current_lags, self._buffer.current_length - 1)
+    valid_lags = valid_lags.clamp_min(0)
+
+    return self._buffer[valid_lags]
+
+  def _update_lags(self) -> None:
+    """Update current lags according to configured policy."""
+    if self.update_period > 0:
+      phase_adjusted_count = (self._step_count + self._phase_offsets) % (
+        self.update_period
+      )
+      should_update = phase_adjusted_count == 0
+    else:
+      should_update = torch.ones(self.batch_size, dtype=torch.bool, device=self.device)
+    new_lags = self._sample_lags(should_update)
+    self._current_lags = torch.where(should_update, new_lags, self._current_lags)
+    self._step_count += 1
+
+  def _sample_lags(self, mask: torch.Tensor) -> torch.Tensor:
+    """Sample new lags for specified environments.
+
+    Args:
+      mask: Boolean mask of shape (batch_size,) indicating which envs to sample.
+
+    Returns:
+      New lags with shape (batch_size,).
+    """
+    if self.per_env:
+      candidate_lags = torch.randint(
+        self.min_lag,
+        self.max_lag + 1,
+        (self.batch_size,),
+        dtype=torch.long,
+        device=self.device,
+        generator=self.generator,
+      )
+    else:
+      shared_lag = torch.randint(
+        self.min_lag,
+        self.max_lag + 1,
+        (1,),
+        dtype=torch.long,
+        device=self.device,
+        generator=self.generator,
+      )
+      candidate_lags = shared_lag.expand(self.batch_size)
+
+    if self.hold_prob > 0.0:
+      should_sample = (
+        torch.rand(
+          self.batch_size,
+          dtype=torch.float32,
+          device=self.device,
+          generator=self.generator,
+        )
+        >= self.hold_prob
+      )
+      update_mask = mask & should_sample
+    else:
+      update_mask = mask
+
+    return torch.where(update_mask, candidate_lags, self._current_lags)
diff --git a/src/mjlab/utils/color.py b/src/mjlab/utils/color.py
new file mode 100644
index 0000000..ee69a2e
--- /dev/null
+++ b/src/mjlab/utils/color.py
@@ -0,0 +1,223 @@
+"""Color manipulation utilities for RGB/HSV conversions and transformations."""
+
+from typing import NamedTuple, Tuple
+
+import numpy as np
+
+
+class RGB(NamedTuple):
+  """RGB color with values in range [0, 1]."""
+
+  r: float
+  g: float
+  b: float
+
+  def to_tuple(self) -> Tuple[float, float, float]:
+    """Convert to tuple representation."""
+    return (self.r, self.g, self.b)
+
+  @staticmethod
+  def random(rng: np.random.Generator) -> "RGB":
+    """Generate a random RGB color."""
+    return RGB(rng.random(), rng.random(), rng.random())
+
+
+class RGBA(NamedTuple):
+  """RGBA color with values in range [0, 1]."""
+
+  r: float
+  g: float
+  b: float
+  a: float
+
+  @classmethod
+  def from_rgb(cls, rgb: RGB, alpha: float = 1.0) -> "RGBA":
+    """Create RGBA from RGB with specified alpha."""
+    return cls(rgb.r, rgb.g, rgb.b, alpha)
+
+  @staticmethod
+  def random(rng: np.random.Generator, alpha: float = 1.0) -> "RGBA":
+    """Generate a random RGBA color with specified alpha."""
+    rgb = RGB.random(rng)
+    return RGBA(rgb.r, rgb.g, rgb.b, alpha)
+
+
+class HSV(NamedTuple):
+  """HSV color representation."""
+
+  h: float  # Hue in range [0, 1].
+  s: float  # Saturation in range [0, 1].
+  v: float  # Value in range [0, 1].
+
+
+def rgb_to_hsv(rgb: Tuple[float, float, float]) -> HSV:
+  """Convert RGB to HSV color space.
+
+  Args:
+    rgb: RGB color tuple with values in range [0, 1].
+
+  Returns:
+    HSV color representation.
+  """
+  r, g, b = rgb
+  max_val = max(r, g, b)
+  min_val = min(r, g, b)
+  delta = max_val - min_val
+
+  # Calculate Value.
+  v = max_val
+
+  # Calculate Saturation.
+  s = 0.0 if max_val == 0 else delta / max_val
+
+  # Calculate Hue.
+  if delta == 0:
+    h = 0.0
+  elif max_val == r:
+    h = ((g - b) / delta) % 6
+  elif max_val == g:
+    h = (b - r) / delta + 2
+  else:
+    h = (r - g) / delta + 4
+
+  h /= 6.0  # Normalize to [0, 1].
+
+  return HSV(h, s, v)
+
+
+def hsv_to_rgb(hsv: HSV) -> Tuple[float, float, float]:
+  """Convert HSV to RGB color space.
+
+  Args:
+    hsv: HSV color representation.
+
+  Returns:
+    RGB color tuple with values in range [0, 1].
+  """
+  h, s, v = hsv.h, hsv.s, hsv.v
+
+  i = int(h * 6)
+  f = h * 6 - i
+  p = v * (1 - s)
+  q = v * (1 - f * s)
+  t = v * (1 - (1 - f) * s)
+
+  i %= 6
+
+  if i == 0:
+    return (v, t, p)
+  elif i == 1:
+    return (q, v, p)
+  elif i == 2:
+    return (p, v, t)
+  elif i == 3:
+    return (p, q, v)
+  elif i == 4:
+    return (t, p, v)
+  else:
+    return (v, p, q)
+
+
+def clamp(value: float, min_val: float = 0.0, max_val: float = 1.0) -> float:
+  """Clamp a value between min and max."""
+  return max(min_val, min(value, max_val))
+
+
+def brand_ramp(
+  base_rgb: Tuple[float, float, float], t: float, alpha: float = 1.0
+) -> Tuple[float, float, float, float]:
+  """Create a color ramp from a base RGB color using parameter t.
+
+  This function creates a color variation by adjusting saturation and
+  value based on the parameter t, useful for creating color gradients
+  or variations of a brand color.
+
+  Args:
+    base_rgb: Base RGB color tuple with values in range [0, 1].
+    t: Ramp parameter in range [0, 1], where 0 is darkest and 1 is brightest.
+    alpha: Alpha transparency value in range [0, 1].
+
+  Returns:
+    RGBA color tuple representing the ramped color.
+
+  Raises:
+    ValueError: If t is not in range [0, 1].
+  """
+  if not 0 <= t <= 1:
+    raise ValueError(f"Parameter t must be in range [0, 1], got {t}")
+
+  hsv = rgb_to_hsv(base_rgb)
+
+  # Ramp value: interpolate from 0.75 to 1.0 based on t.
+  new_v = 0.75 + 0.25 * t
+
+  # Ramp saturation: scale from 85% to 110% of original based on t.
+  saturation_factor = 0.85 + 0.25 * t
+  new_s = clamp(hsv.s * saturation_factor)
+
+  new_hsv = HSV(hsv.h, new_s, new_v)
+  r, g, b = hsv_to_rgb(new_hsv)
+
+  return (r, g, b, alpha)
+
+
+def darken_rgba(
+  rgba: Tuple[float, float, float, float], factor: float = 0.85
+) -> Tuple[float, float, float, float]:
+  """Darken an RGBA color by a given factor.
+
+  Args:
+    rgba: RGBA color tuple with values in range [0, 1].
+    factor: Darkening factor in range [0, 1], where 0 is black and 1 is original.
+
+  Returns:
+    RGBA color tuple with darkened color.
+
+  Raises:
+    ValueError: If factor is not in range [0, 1].
+  """
+  if not 0 <= factor <= 1:
+    raise ValueError(f"Factor must be in range [0, 1], got {factor}")
+
+  r, g, b, a = rgba
+  return (r * factor, g * factor, b * factor, a)
+
+
+def lighten_rgba(
+  rgba: Tuple[float, float, float, float], factor: float = 0.15
+) -> Tuple[float, float, float, float]:
+  """Lighten an RGBA color by interpolating towards white.
+
+  Args:
+    rgba: RGBA color tuple with values in range [0, 1].
+    factor: Lightening factor in range [0, 1], where 0 is original and 1 is white.
+
+  Returns:
+    RGBA color tuple with lightened color.
+
+  Raises:
+    ValueError: If factor is not in range [0, 1].
+  """
+  if not 0 <= factor <= 1:
+    raise ValueError(f"Factor must be in range [0, 1], got {factor}")
+
+  r, g, b, a = rgba
+  return (r + (1 - r) * factor, g + (1 - g) * factor, b + (1 - b) * factor, a)
+
+
+def adjust_saturation(
+  rgb: Tuple[float, float, float], factor: float
+) -> Tuple[float, float, float]:
+  """Adjust the saturation of an RGB color.
+
+  Args:
+    rgb: RGB color tuple with values in range [0, 1].
+    factor: Saturation factor where 0 is grayscale, 1 is original, >1 is more saturated.
+
+  Returns:
+    RGB color tuple with adjusted saturation.
+  """
+  hsv = rgb_to_hsv(rgb)
+  new_s = clamp(hsv.s * factor)
+  new_hsv = HSV(hsv.h, new_s, hsv.v)
+  return hsv_to_rgb(new_hsv)
diff --git a/src/mjlab/utils/gpu.py b/src/mjlab/utils/gpu.py
new file mode 100644
index 0000000..4f12cd3
--- /dev/null
+++ b/src/mjlab/utils/gpu.py
@@ -0,0 +1,81 @@
+"""Utilities for GPU selection and management."""
+
+import os
+from typing import Literal
+
+GpuId = int | str
+
+
+def select_gpus(
+  gpu_ids: list[int] | Literal["all"] | None,
+) -> tuple[list[GpuId] | None, int]:
+  """Select GPUs based on CUDA_VISIBLE_DEVICES and user specification.
+
+  This function treats the `gpu_ids` parameter as indices into the existing
+  CUDA_VISIBLE_DEVICES environment variable. If CUDA_VISIBLE_DEVICES is not set,
+  it defaults to all available GPUs.
+
+  Args:
+    gpu_ids: Either a list of GPU indices (into CUDA_VISIBLE_DEVICES), "all", or None
+    for CPU.
+
+  Returns:
+    A tuple of (selected_gpu_ids, num_gpus) where:
+    - selected_gpu_ids: List of physical GPU IDs (int for numeric, str for MIG
+      UUIDs), or None for CPU mode
+    - num_gpus: Number of GPUs selected (0 for CPU mode)
+
+  Examples:
+    >>> os.environ["CUDA_VISIBLE_DEVICES"] = "0,1,2,3"
+    >>> select_gpus([0, 1])
+    ([0, 1], 2)
+
+    >>> os.environ["CUDA_VISIBLE_DEVICES"] = "1,3"
+    >>> select_gpus([0])  # Selects physical GPU 1
+    ([1], 1)
+
+    >>> select_gpus("all")  # Selects all GPUs in CUDA_VISIBLE_DEVICES
+    ([1, 3], 2)
+
+    >>> select_gpus(None)  # CPU mode
+    (None, 0)
+
+    >>> os.environ["CUDA_VISIBLE_DEVICES"] = ""  # Empty CUDA_VISIBLE_DEVICES
+    >>> select_gpus([0])
+    (None, 0)
+  """
+  # CPU mode requested explicitly.
+  if gpu_ids is None:
+    return None, 0
+
+  # Get existing CUDA_VISIBLE_DEVICES or default to all GPUs.
+  existing_visible_devices = os.environ.get("CUDA_VISIBLE_DEVICES", None)
+
+  if existing_visible_devices is not None:
+    # Parse existing CUDA_VISIBLE_DEVICES.
+    # Use int for numeric IDs, keep as string for MIG UUIDs.
+    available_gpus: list[GpuId] = [
+      int(x.strip()) if x.strip().isdigit() else x.strip()
+      for x in existing_visible_devices.split(",")
+      if x.strip()
+    ]
+    # Empty CUDA_VISIBLE_DEVICES means CPU mode.
+    if not available_gpus:
+      return None, 0
+  else:
+    # If not set, default to all available GPUs.
+    import torch.cuda
+
+    available_gpus: list[GpuId] = list(range(torch.cuda.device_count()))
+
+  # Map gpu_ids indices to actual GPU IDs.
+  selected: list[GpuId]
+  if gpu_ids == "all":
+    selected = available_gpus
+  else:
+    # gpu_ids are indices into available_gpus.
+    selected = [available_gpus[i] for i in gpu_ids]
+
+  num_gpus = len(selected)
+
+  return selected, num_gpus
diff --git a/src/mjlab/utils/lab_api/__init__.py b/src/mjlab/utils/lab_api/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/mjlab/utils/lab_api/math.py b/src/mjlab/utils/lab_api/math.py
new file mode 100644
index 0000000..e42f9a4
--- /dev/null
+++ b/src/mjlab/utils/lab_api/math.py
@@ -0,0 +1,1932 @@
+# Copyright (c) 2022-2025, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+# Modified by mjlab developers:
+#   - 2025-10-05: Replaced quat_rotate_inverse with quat_apply_inverse in
+#     rigid_body_twist_transform() (lines 820-821). The quat_rotate_inverse function was
+#     deprecated/removed in newer PyTorch versions, replaced by quat_apply_inverse with
+#     identical functionality.
+#   - 2025-12-29: Fixed NaN in apply_delta_pose() when rotation angle is zero by clamping
+#     the angle to eps before division.
+
+"""Sub-module containing utilities for various math operations."""
+
+# needed to import for allowing type-hinting: torch.Tensor | np.ndarray
+from __future__ import annotations
+
+import math
+import numpy as np
+import torch
+import torch.nn.functional
+from typing import Literal
+
+"""
+General
+"""
+
+
+@torch.jit.script
+def scale_transform(x: torch.Tensor, lower: torch.Tensor, upper: torch.Tensor) -> torch.Tensor:
+    """Normalizes a given input tensor to a range of [-1, 1].
+
+    .. note::
+        It uses pytorch broadcasting functionality to deal with batched input.
+
+    Args:
+        x: Input tensor of shape (N, dims).
+        lower: The minimum value of the tensor. Shape is (N, dims) or (dims,).
+        upper: The maximum value of the tensor. Shape is (N, dims) or (dims,).
+
+    Returns:
+        Normalized transform of the tensor. Shape is (N, dims).
+    """
+    # default value of center
+    offset = (lower + upper) * 0.5
+    # return normalized tensor
+    return 2 * (x - offset) / (upper - lower)
+
+
+@torch.jit.script
+def unscale_transform(x: torch.Tensor, lower: torch.Tensor, upper: torch.Tensor) -> torch.Tensor:
+    """De-normalizes a given input tensor from range of [-1, 1] to (lower, upper).
+
+    .. note::
+        It uses pytorch broadcasting functionality to deal with batched input.
+
+    Args:
+        x: Input tensor of shape (N, dims).
+        lower: The minimum value of the tensor. Shape is (N, dims) or (dims,).
+        upper: The maximum value of the tensor. Shape is (N, dims) or (dims,).
+
+    Returns:
+        De-normalized transform of the tensor. Shape is (N, dims).
+    """
+    # default value of center
+    offset = (lower + upper) * 0.5
+    # return normalized tensor
+    return x * (upper - lower) * 0.5 + offset
+
+
+@torch.jit.script
+def saturate(x: torch.Tensor, lower: torch.Tensor, upper: torch.Tensor) -> torch.Tensor:
+    """Clamps a given input tensor to (lower, upper).
+
+    It uses pytorch broadcasting functionality to deal with batched input.
+
+    Args:
+        x: Input tensor of shape (N, dims).
+        lower: The minimum value of the tensor. Shape is (N, dims) or (dims,).
+        upper: The maximum value of the tensor. Shape is (N, dims) or (dims,).
+
+    Returns:
+        Clamped transform of the tensor. Shape is (N, dims).
+    """
+    return torch.max(torch.min(x, upper), lower)
+
+
+@torch.jit.script
+def normalize(x: torch.Tensor, eps: float = 1e-9) -> torch.Tensor:
+    """Normalizes a given input tensor to unit length.
+
+    Args:
+        x: Input tensor of shape (N, dims).
+        eps: A small value to avoid division by zero. Defaults to 1e-9.
+
+    Returns:
+        Normalized tensor of shape (N, dims).
+    """
+    return x / x.norm(p=2, dim=-1).clamp(min=eps, max=None).unsqueeze(-1)
+
+
+@torch.jit.script
+def wrap_to_pi(angles: torch.Tensor) -> torch.Tensor:
+    r"""Wraps input angles (in radians) to the range :math:`[-\pi, \pi]`.
+
+    This function wraps angles in radians to the range :math:`[-\pi, \pi]`, such that
+    :math:`\pi` maps to :math:`\pi`, and :math:`-\pi` maps to :math:`-\pi`. In general,
+    odd positive multiples of :math:`\pi` are mapped to :math:`\pi`, and odd negative
+    multiples of :math:`\pi` are mapped to :math:`-\pi`.
+
+    The function behaves similar to MATLAB's `wrapToPi <https://www.mathworks.com/help/map/ref/wraptopi.html>`_
+    function.
+
+    Args:
+        angles: Input angles of any shape.
+
+    Returns:
+        Angles in the range :math:`[-\pi, \pi]`.
+    """
+    # wrap to [0, 2*pi)
+    wrapped_angle = (angles + torch.pi) % (2 * torch.pi)
+    # map to [-pi, pi]
+    # we check for zero in wrapped angle to make it go to pi when input angle is odd multiple of pi
+    return torch.where((wrapped_angle == 0) & (angles > 0), torch.pi, wrapped_angle - torch.pi)
+
+
+@torch.jit.script
+def copysign(mag: float, other: torch.Tensor) -> torch.Tensor:
+    """Create a new floating-point tensor with the magnitude of input and the sign of other, element-wise.
+
+    Note:
+        The implementation follows from `torch.copysign`. The function allows a scalar magnitude.
+
+    Args:
+        mag: The magnitude scalar.
+        other: The tensor containing values whose signbits are applied to magnitude.
+
+    Returns:
+        The output tensor.
+    """
+    mag_torch = abs(mag) * torch.ones_like(other)
+    return torch.copysign(mag_torch, other)
+
+
+"""
+Rotation
+"""
+
+
+@torch.jit.script
+def quat_unique(q: torch.Tensor) -> torch.Tensor:
+    """Convert a unit quaternion to a standard form where the real part is non-negative.
+
+    Quaternion representations have a singularity since ``q`` and ``-q`` represent the same
+    rotation. This function ensures the real part of the quaternion is non-negative.
+
+    Args:
+        q: The quaternion orientation in (w, x, y, z). Shape is (..., 4).
+
+    Returns:
+        Standardized quaternions. Shape is (..., 4).
+    """
+    return torch.where(q[..., 0:1] < 0, -q, q)
+
+
+@torch.jit.script
+def matrix_from_quat(quaternions: torch.Tensor) -> torch.Tensor:
+    """Convert rotations given as quaternions to rotation matrices.
+
+    Args:
+        quaternions: The quaternion orientation in (w, x, y, z). Shape is (..., 4).
+
+    Returns:
+        Rotation matrices. The shape is (..., 3, 3).
+
+    Reference:
+        https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/transforms/rotation_conversions.py#L41-L70
+    """
+    r, i, j, k = torch.unbind(quaternions, -1)
+    # pyre-fixme[58]: `/` is not supported for operand types `float` and `Tensor`.
+    two_s = 2.0 / (quaternions * quaternions).sum(-1)
+
+    o = torch.stack(
+        (
+            1 - two_s * (j * j + k * k),
+            two_s * (i * j - k * r),
+            two_s * (i * k + j * r),
+            two_s * (i * j + k * r),
+            1 - two_s * (i * i + k * k),
+            two_s * (j * k - i * r),
+            two_s * (i * k - j * r),
+            two_s * (j * k + i * r),
+            1 - two_s * (i * i + j * j),
+        ),
+        -1,
+    )
+    return o.reshape(quaternions.shape[:-1] + (3, 3))
+
+
+def convert_quat(quat: torch.Tensor | np.ndarray, to: Literal["xyzw", "wxyz"] = "xyzw") -> torch.Tensor | np.ndarray:
+    """Converts quaternion from one convention to another.
+
+    The convention to convert TO is specified as an optional argument. If to == 'xyzw',
+    then the input is in 'wxyz' format, and vice-versa.
+
+    Args:
+        quat: The quaternion of shape (..., 4).
+        to: Convention to convert quaternion to.. Defaults to "xyzw".
+
+    Returns:
+        The converted quaternion in specified convention.
+
+    Raises:
+        ValueError: Invalid input argument `to`, i.e. not "xyzw" or "wxyz".
+        ValueError: Invalid shape of input `quat`, i.e. not (..., 4,).
+    """
+    # check input is correct
+    if quat.shape[-1] != 4:
+        msg = f"Expected input quaternion shape mismatch: {quat.shape} != (..., 4)."
+        raise ValueError(msg)
+    if to not in ["xyzw", "wxyz"]:
+        msg = f"Expected input argument `to` to be 'xyzw' or 'wxyz'. Received: {to}."
+        raise ValueError(msg)
+    # check if input is numpy array (we support this backend since some classes use numpy)
+    if isinstance(quat, np.ndarray):
+        # use numpy functions
+        if to == "xyzw":
+            # wxyz -> xyzw
+            return np.roll(quat, -1, axis=-1)
+        else:
+            # xyzw -> wxyz
+            return np.roll(quat, 1, axis=-1)
+    else:
+        # convert to torch (sanity check)
+        if not isinstance(quat, torch.Tensor):
+            quat = torch.tensor(quat, dtype=float)
+        # convert to specified quaternion type
+        if to == "xyzw":
+            # wxyz -> xyzw
+            return quat.roll(-1, dims=-1)
+        else:
+            # xyzw -> wxyz
+            return quat.roll(1, dims=-1)
+
+
+@torch.jit.script
+def quat_conjugate(q: torch.Tensor) -> torch.Tensor:
+    """Computes the conjugate of a quaternion.
+
+    Args:
+        q: The quaternion orientation in (w, x, y, z). Shape is (..., 4).
+
+    Returns:
+        The conjugate quaternion in (w, x, y, z). Shape is (..., 4).
+    """
+    shape = q.shape
+    q = q.reshape(-1, 4)
+    return torch.cat((q[..., 0:1], -q[..., 1:]), dim=-1).view(shape)
+
+
+@torch.jit.script
+def quat_inv(q: torch.Tensor, eps: float = 1e-9) -> torch.Tensor:
+    """Computes the inverse of a quaternion.
+
+    Args:
+        q: The quaternion orientation in (w, x, y, z). Shape is (N, 4).
+        eps: A small value to avoid division by zero. Defaults to 1e-9.
+
+    Returns:
+        The inverse quaternion in (w, x, y, z). Shape is (N, 4).
+    """
+    return quat_conjugate(q) / q.pow(2).sum(dim=-1, keepdim=True).clamp(min=eps)
+
+
+@torch.jit.script
+def quat_from_euler_xyz(roll: torch.Tensor, pitch: torch.Tensor, yaw: torch.Tensor) -> torch.Tensor:
+    """Convert rotations given as Euler angles in radians to Quaternions.
+
+    Note:
+        The euler angles are assumed in XYZ convention.
+
+    Args:
+        roll: Rotation around x-axis (in radians). Shape is (N,).
+        pitch: Rotation around y-axis (in radians). Shape is (N,).
+        yaw: Rotation around z-axis (in radians). Shape is (N,).
+
+    Returns:
+        The quaternion in (w, x, y, z). Shape is (N, 4).
+    """
+    cy = torch.cos(yaw * 0.5)
+    sy = torch.sin(yaw * 0.5)
+    cr = torch.cos(roll * 0.5)
+    sr = torch.sin(roll * 0.5)
+    cp = torch.cos(pitch * 0.5)
+    sp = torch.sin(pitch * 0.5)
+    # compute quaternion
+    qw = cy * cr * cp + sy * sr * sp
+    qx = cy * sr * cp - sy * cr * sp
+    qy = cy * cr * sp + sy * sr * cp
+    qz = sy * cr * cp - cy * sr * sp
+
+    return torch.stack([qw, qx, qy, qz], dim=-1)
+
+
+def _sqrt_positive_part(x: torch.Tensor) -> torch.Tensor:
+    """Returns torch.sqrt(torch.max(0, x)) but with a zero subgradient where x is 0.
+
+    Reference:
+        https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/transforms/rotation_conversions.py#L91-L99
+    """
+    positive_mask = x > 0
+    safe_x = torch.where(positive_mask, x, 1.0)
+    return torch.where(positive_mask, torch.sqrt(safe_x), 0.0)
+
+
+@torch.jit.script
+def quat_from_matrix(matrix: torch.Tensor) -> torch.Tensor:
+    """Convert rotations given as rotation matrices to quaternions.
+
+    Args:
+        matrix: The rotation matrices. Shape is (..., 3, 3).
+
+    Returns:
+        The quaternion in (w, x, y, z). Shape is (..., 4).
+
+    Reference:
+        https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/transforms/rotation_conversions.py#L102-L161
+    """
+    if matrix.size(-1) != 3 or matrix.size(-2) != 3:
+        raise ValueError(f"Invalid rotation matrix shape {matrix.shape}.")
+    batch_dim = matrix.shape[:-2]
+    m00, m01, m02, m10, m11, m12, m20, m21, m22 = torch.unbind(
+        matrix.reshape(batch_dim + (9,)), dim=-1
+    )
+    q_abs = _sqrt_positive_part(
+        torch.stack(
+            [
+                1.0 + m00 + m11 + m22,
+                1.0 + m00 - m11 - m22,
+                1.0 - m00 + m11 - m22,
+                1.0 - m00 - m11 + m22,
+            ],
+            dim=-1,
+        )
+    )
+    quat_by_rijk = torch.stack(
+        [
+            torch.stack(
+                [torch.square(q_abs[..., 0]), m21 - m12, m02 - m20, m10 - m01], dim=-1
+            ),
+            torch.stack(
+                [m21 - m12, torch.square(q_abs[..., 1]), m10 + m01, m02 + m20], dim=-1
+            ),
+            torch.stack(
+                [m02 - m20, m10 + m01, torch.square(q_abs[..., 2]), m12 + m21], dim=-1
+            ),
+            torch.stack(
+                [m10 - m01, m20 + m02, m21 + m12, torch.square(q_abs[..., 3])], dim=-1
+            ),
+        ],
+        dim=-2,
+    )
+    # Floor of 0.1 keeps the divisor away from zero; ill-conditioned
+    # candidates will not be selected by the argmax below.
+    quat_candidates = quat_by_rijk / (2.0 * q_abs[..., None].clamp_min(0.1))
+
+    # if not for numerical problems, quat_candidates[i] should be same (up to a sign),
+    # forall i; we pick the best-conditioned one (with the largest denominator)
+    indices = q_abs.argmax(dim=-1, keepdim=True)
+    gather_indices = indices.unsqueeze(-1).expand(batch_dim + (1, 4))
+    return torch.gather(quat_candidates, -2, gather_indices).squeeze(-2)
+
+
+def _axis_angle_rotation(axis: Literal["X", "Y", "Z"], angle: torch.Tensor) -> torch.Tensor:
+    """Return the rotation matrices for one of the rotations about an axis of which Euler angles describe,
+    for each value of the angle given.
+
+    Args:
+        axis: Axis label "X" or "Y or "Z".
+        angle: Euler angles in radians of any shape.
+
+    Returns:
+        Rotation matrices. Shape is (..., 3, 3).
+
+    Reference:
+        https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/transforms/rotation_conversions.py#L164-L191
+    """
+    cos = torch.cos(angle)
+    sin = torch.sin(angle)
+    one = torch.ones_like(angle)
+    zero = torch.zeros_like(angle)
+
+    if axis == "X":
+        R_flat = (one, zero, zero, zero, cos, -sin, zero, sin, cos)
+    elif axis == "Y":
+        R_flat = (cos, zero, sin, zero, one, zero, -sin, zero, cos)
+    elif axis == "Z":
+        R_flat = (cos, -sin, zero, sin, cos, zero, zero, zero, one)
+    else:
+        raise ValueError("letter must be either X, Y or Z.")
+
+    return torch.stack(R_flat, -1).reshape(angle.shape + (3, 3))
+
+
+def matrix_from_euler(euler_angles: torch.Tensor, convention: str) -> torch.Tensor:
+    """
+    Convert rotations given as Euler angles (intrinsic) in radians to rotation matrices.
+
+    Args:
+        euler_angles: Euler angles in radians. Shape is (..., 3).
+        convention: Convention string of three uppercase letters from {"X", "Y", and "Z"}.
+            For example, "XYZ" means that the rotations should be applied first about x,
+            then y, then z.
+
+    Returns:
+        Rotation matrices. Shape is (..., 3, 3).
+
+    Reference:
+        https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/transforms/rotation_conversions.py#L194-L220
+    """
+    if euler_angles.dim() == 0 or euler_angles.shape[-1] != 3:
+        raise ValueError("Invalid input euler angles.")
+    if len(convention) != 3:
+        raise ValueError("Convention must have 3 letters.")
+    if convention[1] in (convention[0], convention[2]):
+        raise ValueError(f"Invalid convention {convention}.")
+    for letter in convention:
+        if letter not in ("X", "Y", "Z"):
+            raise ValueError(f"Invalid letter {letter} in convention string.")
+    matrices = [_axis_angle_rotation(c, e) for c, e in zip(convention, torch.unbind(euler_angles, -1))]
+    # return functools.reduce(torch.matmul, matrices)
+    return torch.matmul(torch.matmul(matrices[0], matrices[1]), matrices[2])
+
+
+@torch.jit.script
+def euler_xyz_from_quat(
+    quat: torch.Tensor, wrap_to_2pi: bool = False
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    """Convert rotations given as quaternions to Euler angles in radians.
+
+    Note:
+        The euler angles are assumed in XYZ extrinsic convention.
+
+    Args:
+        quat: The quaternion orientation in (w, x, y, z). Shape is (N, 4).
+        wrap_to_2pi (bool): Whether to wrap output Euler angles into [0, 2π). If
+            False, angles are returned in the default range (−π, π]. Defaults to
+            False.
+
+    Returns:
+        A tuple containing roll-pitch-yaw. Each element is a tensor of shape (N,).
+
+    Reference:
+        https://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles
+    """
+    q_w, q_x, q_y, q_z = quat[:, 0], quat[:, 1], quat[:, 2], quat[:, 3]
+    # roll (x-axis rotation)
+    sin_roll = 2.0 * (q_w * q_x + q_y * q_z)
+    cos_roll = 1 - 2 * (q_x * q_x + q_y * q_y)
+    roll = torch.atan2(sin_roll, cos_roll)
+
+    # pitch (y-axis rotation)
+    sin_pitch = 2.0 * (q_w * q_y - q_z * q_x)
+    pitch = torch.where(torch.abs(sin_pitch) >= 1, copysign(torch.pi / 2.0, sin_pitch), torch.asin(sin_pitch))
+
+    # yaw (z-axis rotation)
+    sin_yaw = 2.0 * (q_w * q_z + q_x * q_y)
+    cos_yaw = 1 - 2 * (q_y * q_y + q_z * q_z)
+    yaw = torch.atan2(sin_yaw, cos_yaw)
+
+    if wrap_to_2pi:
+        return roll % (2 * torch.pi), pitch % (2 * torch.pi), yaw % (2 * torch.pi)
+    return roll, pitch, yaw
+
+
+@torch.jit.script
+def axis_angle_from_quat(quat: torch.Tensor, eps: float = 1.0e-6) -> torch.Tensor:
+    """Convert rotations given as quaternions to axis/angle.
+
+    Args:
+        quat: The quaternion orientation in (w, x, y, z). Shape is (..., 4).
+        eps: The tolerance for Taylor approximation. Defaults to 1.0e-6.
+
+    Returns:
+        Rotations given as a vector in axis angle form. Shape is (..., 3).
+        The vector's magnitude is the angle turned anti-clockwise in radians around the vector's direction.
+
+    Reference:
+        https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/transforms/rotation_conversions.py#L526-L554
+    """
+    # Modified to take in quat as [q_w, q_x, q_y, q_z]
+    # Quaternion is [q_w, q_x, q_y, q_z] = [cos(theta/2), n_x * sin(theta/2), n_y * sin(theta/2), n_z * sin(theta/2)]
+    # Axis-angle is [a_x, a_y, a_z] = [theta * n_x, theta * n_y, theta * n_z]
+    # Thus, axis-angle is [q_x, q_y, q_z] / (sin(theta/2) / theta)
+    # When theta = 0, (sin(theta/2) / theta) is undefined
+    # However, as theta --> 0, we can use the Taylor approximation 1/2 - theta^2 / 48
+    quat = quat * (1.0 - 2.0 * (quat[..., 0:1] < 0.0))
+    mag = torch.linalg.norm(quat[..., 1:], dim=-1)
+    half_angle = torch.atan2(mag, quat[..., 0])
+    angle = 2.0 * half_angle
+    # check whether to apply Taylor approximation
+    sin_half_angles_over_angles = torch.where(
+        angle.abs() > eps, torch.sin(half_angle) / angle, 0.5 - angle * angle / 48
+    )
+    return quat[..., 1:4] / sin_half_angles_over_angles.unsqueeze(-1)
+
+
+@torch.jit.script
+def quat_from_angle_axis(angle: torch.Tensor, axis: torch.Tensor) -> torch.Tensor:
+    """Convert rotations given as angle-axis to quaternions.
+
+    Args:
+        angle: The angle turned anti-clockwise in radians around the vector's direction. Shape is (N,).
+        axis: The axis of rotation. Shape is (N, 3).
+
+    Returns:
+        The quaternion in (w, x, y, z). Shape is (N, 4).
+    """
+    theta = (angle / 2).unsqueeze(-1)
+    xyz = normalize(axis) * theta.sin()
+    w = theta.cos()
+    return normalize(torch.cat([w, xyz], dim=-1))
+
+
+@torch.jit.script
+def quat_mul(q1: torch.Tensor, q2: torch.Tensor) -> torch.Tensor:
+    """Multiply two quaternions together.
+
+    Args:
+        q1: The first quaternion in (w, x, y, z). Shape is (..., 4).
+        q2: The second quaternion in (w, x, y, z). Shape is (..., 4).
+
+    Returns:
+        The product of the two quaternions in (w, x, y, z). Shape is (..., 4).
+
+    Raises:
+        ValueError: Input shapes of ``q1`` and ``q2`` are not matching.
+    """
+    # check input is correct
+    if q1.shape != q2.shape:
+        msg = f"Expected input quaternion shape mismatch: {q1.shape} != {q2.shape}."
+        raise ValueError(msg)
+    # reshape to (N, 4) for multiplication
+    shape = q1.shape
+    q1 = q1.reshape(-1, 4)
+    q2 = q2.reshape(-1, 4)
+    # extract components from quaternions
+    w1, x1, y1, z1 = q1[:, 0], q1[:, 1], q1[:, 2], q1[:, 3]
+    w2, x2, y2, z2 = q2[:, 0], q2[:, 1], q2[:, 2], q2[:, 3]
+    # perform multiplication
+    ww = (z1 + x1) * (x2 + y2)
+    yy = (w1 - y1) * (w2 + z2)
+    zz = (w1 + y1) * (w2 - z2)
+    xx = ww + yy + zz
+    qq = 0.5 * (xx + (z1 - x1) * (x2 - y2))
+    w = qq - ww + (z1 - y1) * (y2 - z2)
+    x = qq - xx + (x1 + w1) * (x2 + w2)
+    y = qq - yy + (w1 - x1) * (y2 + z2)
+    z = qq - zz + (z1 + y1) * (w2 - x2)
+
+    return torch.stack([w, x, y, z], dim=-1).view(shape)
+
+
+@torch.jit.script
+def yaw_quat(quat: torch.Tensor) -> torch.Tensor:
+    """Extract the yaw component of a quaternion.
+
+    Args:
+        quat: The orientation in (w, x, y, z). Shape is (..., 4)
+
+    Returns:
+        A quaternion with only yaw component.
+    """
+    shape = quat.shape
+    quat_yaw = quat.view(-1, 4)
+    qw = quat_yaw[:, 0]
+    qx = quat_yaw[:, 1]
+    qy = quat_yaw[:, 2]
+    qz = quat_yaw[:, 3]
+    yaw = torch.atan2(2 * (qw * qz + qx * qy), 1 - 2 * (qy * qy + qz * qz))
+    quat_yaw = torch.zeros_like(quat_yaw)
+    quat_yaw[:, 3] = torch.sin(yaw / 2)
+    quat_yaw[:, 0] = torch.cos(yaw / 2)
+    quat_yaw = normalize(quat_yaw)
+    return quat_yaw.view(shape)
+
+
+@torch.jit.script
+def quat_box_minus(q1: torch.Tensor, q2: torch.Tensor) -> torch.Tensor:
+    """The box-minus operator (quaternion difference) between two quaternions.
+
+    Args:
+        q1: The first quaternion in (w, x, y, z). Shape is (N, 4).
+        q2: The second quaternion in (w, x, y, z). Shape is (N, 4).
+
+    Returns:
+        The difference between the two quaternions. Shape is (N, 3).
+
+    Reference:
+        https://github.com/ANYbotics/kindr/blob/master/doc/cheatsheet/cheatsheet_latest.pdf
+    """
+    quat_diff = quat_mul(q1, quat_conjugate(q2))  # q1 * q2^-1
+    return axis_angle_from_quat(quat_diff)  # log(qd)
+
+
+@torch.jit.script
+def quat_box_plus(q: torch.Tensor, delta: torch.Tensor, eps: float = 1.0e-6) -> torch.Tensor:
+    """The box-plus operator (quaternion update) to apply an increment to a quaternion.
+
+    Args:
+        q: The initial quaternion in (w, x, y, z). Shape is (N, 4).
+        delta: The axis-angle perturbation. Shape is (N, 3).
+            eps: A small value to avoid division by zero. Defaults to 1e-6.
+
+    Returns:
+        The updated quaternion after applying the perturbation. Shape is (N, 4).
+
+    Reference:
+        https://github.com/ANYbotics/kindr/blob/master/doc/cheatsheet/cheatsheet_latest.pdf
+    """
+    delta_norm = torch.clamp_min(torch.linalg.norm(delta, dim=-1, keepdim=True), min=eps)
+    delta_quat = quat_from_angle_axis(delta_norm.squeeze(-1), delta / delta_norm)  # exp(dq)
+    new_quat = quat_mul(delta_quat, q)  # Apply perturbation
+    return quat_unique(new_quat)
+
+
+@torch.jit.script
+def quat_apply(quat: torch.Tensor, vec: torch.Tensor) -> torch.Tensor:
+    """Apply a quaternion rotation to a vector.
+
+    Args:
+        quat: The quaternion in (w, x, y, z). Shape is (..., 4).
+        vec: The vector in (x, y, z). Shape is (..., 3).
+
+    Returns:
+        The rotated vector in (x, y, z). Shape is (..., 3).
+    """
+    # store shape
+    shape = vec.shape
+    # reshape to (N, 3) for multiplication
+    quat = quat.reshape(-1, 4)
+    vec = vec.reshape(-1, 3)
+    # extract components from quaternions
+    xyz = quat[:, 1:]
+    t = xyz.cross(vec, dim=-1) * 2
+    return (vec + quat[:, 0:1] * t + xyz.cross(t, dim=-1)).view(shape)
+
+
+@torch.jit.script
+def quat_apply_inverse(quat: torch.Tensor, vec: torch.Tensor) -> torch.Tensor:
+    """Apply an inverse quaternion rotation to a vector.
+
+    Args:
+        quat: The quaternion in (w, x, y, z). Shape is (..., 4).
+        vec: The vector in (x, y, z). Shape is (..., 3).
+
+    Returns:
+        The rotated vector in (x, y, z). Shape is (..., 3).
+    """
+    # store shape
+    shape = vec.shape
+    # reshape to (N, 3) for multiplication
+    quat = quat.reshape(-1, 4)
+    vec = vec.reshape(-1, 3)
+    # extract components from quaternions
+    xyz = quat[:, 1:]
+    t = xyz.cross(vec, dim=-1) * 2
+    return (vec - quat[:, 0:1] * t + xyz.cross(t, dim=-1)).view(shape)
+
+
+@torch.jit.script
+def quat_apply_yaw(quat: torch.Tensor, vec: torch.Tensor) -> torch.Tensor:
+    """Rotate a vector only around the yaw-direction.
+
+    Args:
+        quat: The orientation in (w, x, y, z). Shape is (N, 4).
+        vec: The vector in (x, y, z). Shape is (N, 3).
+
+    Returns:
+        The rotated vector in (x, y, z). Shape is (N, 3).
+    """
+    quat_yaw = yaw_quat(quat)
+    return quat_apply(quat_yaw, vec)
+
+
+@torch.jit.script
+def quat_error_magnitude(q1: torch.Tensor, q2: torch.Tensor) -> torch.Tensor:
+    """Computes the rotation difference between two quaternions.
+
+    Args:
+        q1: The first quaternion in (w, x, y, z). Shape is (..., 4).
+        q2: The second quaternion in (w, x, y, z). Shape is (..., 4).
+
+    Returns:
+        Angular error between input quaternions in radians.
+    """
+    axis_angle_error = quat_box_minus(q1, q2)
+    return torch.norm(axis_angle_error, dim=-1)
+
+
+@torch.jit.script
+def skew_symmetric_matrix(vec: torch.Tensor) -> torch.Tensor:
+    """Computes the skew-symmetric matrix of a vector.
+
+    Args:
+        vec: The input vector. Shape is (3,) or (N, 3).
+
+    Returns:
+        The skew-symmetric matrix. Shape is (1, 3, 3) or (N, 3, 3).
+
+    Raises:
+        ValueError: If input tensor is not of shape (..., 3).
+    """
+    # check input is correct
+    if vec.shape[-1] != 3:
+        raise ValueError(f"Expected input vector shape mismatch: {vec.shape} != (..., 3).")
+    # unsqueeze the last dimension
+    if vec.ndim == 1:
+        vec = vec.unsqueeze(0)
+    # create a skew-symmetric matrix
+    skew_sym_mat = torch.zeros(vec.shape[0], 3, 3, device=vec.device, dtype=vec.dtype)
+    skew_sym_mat[:, 0, 1] = -vec[:, 2]
+    skew_sym_mat[:, 0, 2] = vec[:, 1]
+    skew_sym_mat[:, 1, 2] = -vec[:, 0]
+    skew_sym_mat[:, 1, 0] = vec[:, 2]
+    skew_sym_mat[:, 2, 0] = -vec[:, 1]
+    skew_sym_mat[:, 2, 1] = vec[:, 0]
+
+    return skew_sym_mat
+
+
+"""
+Transformations
+"""
+
+
+def is_identity_pose(pos: torch.tensor, rot: torch.tensor) -> bool:
+    """Checks if input poses are identity transforms.
+
+    The function checks if the input position and orientation are close to zero and
+    identity respectively using L2-norm. It does NOT check the error in the orientation.
+
+    Args:
+        pos: The cartesian position. Shape is (N, 3).
+        rot: The quaternion in (w, x, y, z). Shape is (N, 4).
+
+    Returns:
+        True if all the input poses result in identity transform. Otherwise, False.
+    """
+    # create identity transformations
+    pos_identity = torch.zeros_like(pos)
+    rot_identity = torch.zeros_like(rot)
+    rot_identity[..., 0] = 1
+    # compare input to identity
+    return torch.allclose(pos, pos_identity) and torch.allclose(rot, rot_identity)
+
+
+@torch.jit.script
+def combine_frame_transforms(
+    t01: torch.Tensor, q01: torch.Tensor, t12: torch.Tensor | None = None, q12: torch.Tensor | None = None
+) -> tuple[torch.Tensor, torch.Tensor]:
+    r"""Combine transformations between two reference frames into a stationary frame.
+
+    It performs the following transformation operation: :math:`T_{02} = T_{01} \times T_{12}`,
+    where :math:`T_{AB}` is the homogeneous transformation matrix from frame A to B.
+
+    Args:
+        t01: Position of frame 1 w.r.t. frame 0. Shape is (N, 3).
+        q01: Quaternion orientation of frame 1 w.r.t. frame 0 in (w, x, y, z). Shape is (N, 4).
+        t12: Position of frame 2 w.r.t. frame 1. Shape is (N, 3).
+            Defaults to None, in which case the position is assumed to be zero.
+        q12: Quaternion orientation of frame 2 w.r.t. frame 1 in (w, x, y, z). Shape is (N, 4).
+            Defaults to None, in which case the orientation is assumed to be identity.
+
+    Returns:
+        A tuple containing the position and orientation of frame 2 w.r.t. frame 0.
+        Shape of the tensors are (N, 3) and (N, 4) respectively.
+    """
+    # compute orientation
+    if q12 is not None:
+        q02 = quat_mul(q01, q12)
+    else:
+        q02 = q01
+    # compute translation
+    if t12 is not None:
+        t02 = t01 + quat_apply(q01, t12)
+    else:
+        t02 = t01
+
+    return t02, q02
+
+
+def rigid_body_twist_transform(
+    v0: torch.Tensor, w0: torch.Tensor, t01: torch.Tensor, q01: torch.Tensor
+) -> tuple[torch.Tensor, torch.Tensor]:
+    r"""Transform the linear and angular velocity of a rigid body between reference frames.
+
+    Given the twist of 0 relative to frame 0, this function computes the twist of 1 relative to frame 1
+    from the position and orientation of frame 1 relative to frame 0. The transformation follows the
+    equations:
+
+    .. math::
+
+        w_11 = R_{10} w_00 = R_{01}^{-1} w_00
+        v_11 = R_{10} v_00 + R_{10} (w_00 \times t_01) = R_{01}^{-1} (v_00 + (w_00 \times t_01))
+
+    where
+
+        - :math:`R_{01}` is the rotation matrix from frame 0 to frame 1 derived from quaternion :math:`q_{01}`.
+        - :math:`t_{01}` is the position of frame 1 relative to frame 0 expressed in frame 0
+        - :math:`w_0` is the angular velocity of 0 in frame 0
+        - :math:`v_0` is the linear velocity of 0 in frame 0
+
+    Args:
+        v0: Linear velocity of 0 in frame 0. Shape is (N, 3).
+        w0: Angular velocity of 0 in frame 0. Shape is (N, 3).
+        t01: Position of frame 1 w.r.t. frame 0. Shape is (N, 3).
+        q01: Quaternion orientation of frame 1 w.r.t. frame 0 in (w, x, y, z). Shape is (N, 4).
+
+    Returns:
+        A tuple containing:
+        - The transformed linear velocity in frame 1. Shape is (N, 3).
+        - The transformed angular velocity in frame 1. Shape is (N, 3).
+    """
+    w1 = quat_apply_inverse(q01, w0)
+    v1 = quat_apply_inverse(q01, v0 + torch.cross(w0, t01, dim=-1))
+    return v1, w1
+
+
+# @torch.jit.script
+def subtract_frame_transforms(
+    t01: torch.Tensor, q01: torch.Tensor, t02: torch.Tensor | None = None, q02: torch.Tensor | None = None
+) -> tuple[torch.Tensor, torch.Tensor]:
+    r"""Subtract transformations between two reference frames into a stationary frame.
+
+    It performs the following transformation operation: :math:`T_{12} = T_{01}^{-1} \times T_{02}`,
+    where :math:`T_{AB}` is the homogeneous transformation matrix from frame A to B.
+
+    Args:
+        t01: Position of frame 1 w.r.t. frame 0. Shape is (N, 3).
+        q01: Quaternion orientation of frame 1 w.r.t. frame 0 in (w, x, y, z). Shape is (N, 4).
+        t02: Position of frame 2 w.r.t. frame 0. Shape is (N, 3).
+            Defaults to None, in which case the position is assumed to be zero.
+        q02: Quaternion orientation of frame 2 w.r.t. frame 0 in (w, x, y, z). Shape is (N, 4).
+            Defaults to None, in which case the orientation is assumed to be identity.
+
+    Returns:
+        A tuple containing the position and orientation of frame 2 w.r.t. frame 1.
+        Shape of the tensors are (N, 3) and (N, 4) respectively.
+    """
+    # compute orientation
+    q10 = quat_inv(q01)
+    if q02 is not None:
+        q12 = quat_mul(q10, q02)
+    else:
+        q12 = q10
+    # compute translation
+    if t02 is not None:
+        t12 = quat_apply(q10, t02 - t01)
+    else:
+        t12 = quat_apply(q10, -t01)
+    return t12, q12
+
+
+# @torch.jit.script
+def compute_pose_error(
+    t01: torch.Tensor,
+    q01: torch.Tensor,
+    t02: torch.Tensor,
+    q02: torch.Tensor,
+    rot_error_type: Literal["quat", "axis_angle"] = "axis_angle",
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Compute the position and orientation error between source and target frames.
+
+    Args:
+        t01: Position of source frame. Shape is (N, 3).
+        q01: Quaternion orientation of source frame in (w, x, y, z). Shape is (N, 4).
+        t02: Position of target frame. Shape is (N, 3).
+        q02: Quaternion orientation of target frame in (w, x, y, z). Shape is (N, 4).
+        rot_error_type: The rotation error type to return: "quat", "axis_angle".
+            Defaults to "axis_angle".
+
+    Returns:
+        A tuple containing position and orientation error. Shape of position error is (N, 3).
+        Shape of orientation error depends on the value of :attr:`rot_error_type`:
+
+        - If :attr:`rot_error_type` is "quat", the orientation error is returned
+          as a quaternion. Shape is (N, 4).
+        - If :attr:`rot_error_type` is "axis_angle", the orientation error is
+          returned as an axis-angle vector. Shape is (N, 3).
+
+    Raises:
+        ValueError: Invalid rotation error type.
+    """
+    # Compute quaternion error (i.e., difference quaternion)
+    # Reference: https://personal.utdallas.edu/~sxb027100/dock/quaternion.html
+    # q_current_norm = q_current * q_current_conj
+    source_quat_norm = quat_mul(q01, quat_conjugate(q01))[:, 0]
+    # q_current_inv = q_current_conj / q_current_norm
+    source_quat_inv = quat_conjugate(q01) / source_quat_norm.unsqueeze(-1)
+    # q_error = q_target * q_current_inv
+    quat_error = quat_mul(q02, source_quat_inv)
+
+    # Compute position error
+    pos_error = t02 - t01
+
+    # return error based on specified type
+    if rot_error_type == "quat":
+        return pos_error, quat_error
+    elif rot_error_type == "axis_angle":
+        # Convert to axis-angle error
+        axis_angle_error = axis_angle_from_quat(quat_error)
+        return pos_error, axis_angle_error
+    else:
+        raise ValueError(f"Unsupported orientation error type: {rot_error_type}. Valid: 'quat', 'axis_angle'.")
+
+
+@torch.jit.script
+def apply_delta_pose(
+    source_pos: torch.Tensor, source_rot: torch.Tensor, delta_pose: torch.Tensor, eps: float = 1.0e-6
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Applies delta pose transformation on source pose.
+
+    The first three elements of `delta_pose` are interpreted as cartesian position displacement.
+    The remaining three elements of `delta_pose` are interpreted as orientation displacement
+    in the angle-axis format.
+
+    Args:
+        source_pos: Position of source frame. Shape is (N, 3).
+        source_rot: Quaternion orientation of source frame in (w, x, y, z). Shape is (N, 4)..
+        delta_pose: Position and orientation displacements. Shape is (N, 6).
+        eps: The tolerance to consider orientation displacement as zero. Defaults to 1.0e-6.
+
+    Returns:
+        A tuple containing the displaced position and orientation frames.
+        Shape of the tensors are (N, 3) and (N, 4) respectively.
+    """
+    # number of poses given
+    num_poses = source_pos.shape[0]
+    device = source_pos.device
+
+    # interpret delta_pose[:, 0:3] as target position displacements
+    target_pos = source_pos + delta_pose[:, 0:3]
+    # interpret delta_pose[:, 3:6] as target rotation displacements
+    rot_actions = delta_pose[:, 3:6]
+    angle = torch.linalg.vector_norm(rot_actions, dim=1)
+    safe_angle = torch.clamp_min(angle, eps)
+    axis = rot_actions / safe_angle.unsqueeze(-1)
+    # change from axis-angle to quat convention
+    identity_quat = torch.tensor([1.0, 0.0, 0.0, 0.0], device=device).repeat(num_poses, 1)
+    rot_delta_quat = torch.where(
+        angle.unsqueeze(-1).repeat(1, 4) > eps, quat_from_angle_axis(angle, axis), identity_quat
+    )
+    # TODO: Check if this is the correct order for this multiplication.
+    target_rot = quat_mul(rot_delta_quat, source_rot)
+
+    return target_pos, target_rot
+
+
+# @torch.jit.script
+def transform_points(
+    points: torch.Tensor, pos: torch.Tensor | None = None, quat: torch.Tensor | None = None
+) -> torch.Tensor:
+    r"""Transform input points in a given frame to a target frame.
+
+    This function transform points from a source frame to a target frame. The transformation is defined by the
+    position :math:`t` and orientation :math:`R` of the target frame in the source frame.
+
+    .. math::
+        p_{target} = R_{target} \times p_{source} + t_{target}
+
+    If the input `points` is a batch of points, the inputs `pos` and `quat` must be either a batch of
+    positions and quaternions or a single position and quaternion. If the inputs `pos` and `quat` are
+    a single position and quaternion, the same transformation is applied to all points in the batch.
+
+    If either the inputs :attr:`pos` and :attr:`quat` are None, the corresponding transformation is not applied.
+
+    Args:
+        points: Points to transform. Shape is (N, P, 3) or (P, 3).
+        pos: Position of the target frame. Shape is (N, 3) or (3,).
+            Defaults to None, in which case the position is assumed to be zero.
+        quat: Quaternion orientation of the target frame in (w, x, y, z). Shape is (N, 4) or (4,).
+            Defaults to None, in which case the orientation is assumed to be identity.
+
+    Returns:
+        Transformed points in the target frame. Shape is (N, P, 3) or (P, 3).
+
+    Raises:
+        ValueError: If the inputs `points` is not of shape (N, P, 3) or (P, 3).
+        ValueError: If the inputs `pos` is not of shape (N, 3) or (3,).
+        ValueError: If the inputs `quat` is not of shape (N, 4) or (4,).
+    """
+    points_batch = points.clone()
+    # check if inputs are batched
+    is_batched = points_batch.dim() == 3
+    # -- check inputs
+    if points_batch.dim() == 2:
+        points_batch = points_batch[None]  # (P, 3) -> (1, P, 3)
+    if points_batch.dim() != 3:
+        raise ValueError(f"Expected points to have dim = 2 or dim = 3: got shape {points.shape}")
+    if not (pos is None or pos.dim() == 1 or pos.dim() == 2):
+        raise ValueError(f"Expected pos to have dim = 1 or dim = 2: got shape {pos.shape}")
+    if not (quat is None or quat.dim() == 1 or quat.dim() == 2):
+        raise ValueError(f"Expected quat to have dim = 1 or dim = 2: got shape {quat.shape}")
+    # -- rotation
+    if quat is not None:
+        # convert to batched rotation matrix
+        rot_mat = matrix_from_quat(quat)
+        if rot_mat.dim() == 2:
+            rot_mat = rot_mat[None]  # (3, 3) -> (1, 3, 3)
+        # convert points to matching batch size (N, P, 3) -> (N, 3, P)
+        # and apply rotation
+        points_batch = torch.matmul(rot_mat, points_batch.transpose_(1, 2))
+        # (N, 3, P) -> (N, P, 3)
+        points_batch = points_batch.transpose_(1, 2)
+    # -- translation
+    if pos is not None:
+        # convert to batched translation vector
+        if pos.dim() == 1:
+            pos = pos[None, None, :]  # (3,) -> (1, 1, 3)
+        else:
+            pos = pos[:, None, :]  # (N, 3) -> (N, 1, 3)
+        # apply translation
+        points_batch += pos
+    # -- return points in same shape as input
+    if not is_batched:
+        points_batch = points_batch.squeeze(0)  # (1, P, 3) -> (P, 3)
+
+    return points_batch
+
+
+"""
+Projection operations.
+"""
+
+
+@torch.jit.script
+def orthogonalize_perspective_depth(depth: torch.Tensor, intrinsics: torch.Tensor) -> torch.Tensor:
+    """Converts perspective depth image to orthogonal depth image.
+
+    Perspective depth images contain distances measured from the camera's optical center.
+    Meanwhile, orthogonal depth images provide the distance from the camera's image plane.
+    This method uses the camera geometry to convert perspective depth to orthogonal depth image.
+
+    The function assumes that the width and height are both greater than 1.
+
+    Args:
+        depth: The perspective depth images. Shape is (H, W) or or (H, W, 1) or (N, H, W) or (N, H, W, 1).
+        intrinsics: The camera's calibration matrix. If a single matrix is provided, the same
+            calibration matrix is used across all the depth images in the batch.
+            Shape is (3, 3) or (N, 3, 3).
+
+    Returns:
+        The orthogonal depth images. Shape matches the input shape of depth images.
+
+    Raises:
+        ValueError: When depth is not of shape (H, W) or (H, W, 1) or (N, H, W) or (N, H, W, 1).
+        ValueError: When intrinsics is not of shape (3, 3) or (N, 3, 3).
+    """
+    # Clone inputs to avoid in-place modifications
+    perspective_depth_batch = depth.clone()
+    intrinsics_batch = intrinsics.clone()
+
+    # Check if inputs are batched
+    is_batched = perspective_depth_batch.dim() == 4 or (
+        perspective_depth_batch.dim() == 3 and perspective_depth_batch.shape[-1] != 1
+    )
+
+    # Track whether the last dimension was singleton
+    add_last_dim = False
+    if perspective_depth_batch.dim() == 4 and perspective_depth_batch.shape[-1] == 1:
+        add_last_dim = True
+        perspective_depth_batch = perspective_depth_batch.squeeze(dim=3)  # (N, H, W, 1) -> (N, H, W)
+    if perspective_depth_batch.dim() == 3 and perspective_depth_batch.shape[-1] == 1:
+        add_last_dim = True
+        perspective_depth_batch = perspective_depth_batch.squeeze(dim=2)  # (H, W, 1) -> (H, W)
+
+    if perspective_depth_batch.dim() == 2:
+        perspective_depth_batch = perspective_depth_batch[None]  # (H, W) -> (1, H, W)
+
+    if intrinsics_batch.dim() == 2:
+        intrinsics_batch = intrinsics_batch[None]  # (3, 3) -> (1, 3, 3)
+
+    if is_batched and intrinsics_batch.shape[0] == 1:
+        intrinsics_batch = intrinsics_batch.expand(perspective_depth_batch.shape[0], -1, -1)  # (1, 3, 3) -> (N, 3, 3)
+
+    # Validate input shapes
+    if perspective_depth_batch.dim() != 3:
+        raise ValueError(f"Expected depth images to have 2, 3, or 4 dimensions; got {depth.shape}.")
+    if intrinsics_batch.dim() != 3:
+        raise ValueError(f"Expected intrinsics to have shape (3, 3) or (N, 3, 3); got {intrinsics.shape}.")
+
+    # Image dimensions
+    im_height, im_width = perspective_depth_batch.shape[1:]
+
+    # Get the intrinsics parameters
+    fx = intrinsics_batch[:, 0, 0].view(-1, 1, 1)
+    fy = intrinsics_batch[:, 1, 1].view(-1, 1, 1)
+    cx = intrinsics_batch[:, 0, 2].view(-1, 1, 1)
+    cy = intrinsics_batch[:, 1, 2].view(-1, 1, 1)
+
+    # Create meshgrid of pixel coordinates
+    u_grid = torch.arange(im_width, device=depth.device, dtype=depth.dtype)
+    v_grid = torch.arange(im_height, device=depth.device, dtype=depth.dtype)
+    u_grid, v_grid = torch.meshgrid(u_grid, v_grid, indexing="xy")
+
+    # Expand the grids for batch processing
+    u_grid = u_grid.unsqueeze(0).expand(perspective_depth_batch.shape[0], -1, -1)
+    v_grid = v_grid.unsqueeze(0).expand(perspective_depth_batch.shape[0], -1, -1)
+
+    # Compute the squared terms for efficiency
+    x_term = ((u_grid - cx) / fx) ** 2
+    y_term = ((v_grid - cy) / fy) ** 2
+
+    # Calculate the orthogonal (normal) depth
+    orthogonal_depth = perspective_depth_batch / torch.sqrt(1 + x_term + y_term)
+
+    # Restore the last dimension if it was present in the input
+    if add_last_dim:
+        orthogonal_depth = orthogonal_depth.unsqueeze(-1)
+
+    # Return to original shape if input was not batched
+    if not is_batched:
+        orthogonal_depth = orthogonal_depth.squeeze(0)
+
+    return orthogonal_depth
+
+
+@torch.jit.script
+def unproject_depth(depth: torch.Tensor, intrinsics: torch.Tensor, is_ortho: bool = True) -> torch.Tensor:
+    r"""Un-project depth image into a pointcloud.
+
+    This function converts orthogonal or perspective depth images into points given the calibration matrix
+    of the camera. It uses the following transformation based on camera geometry:
+
+    .. math::
+        p_{3D} = K^{-1} \times [u, v, 1]^T \times d
+
+    where :math:`p_{3D}` is the 3D point, :math:`d` is the depth value (measured from the image plane),
+    :math:`u` and :math:`v` are the pixel coordinates and :math:`K` is the intrinsic matrix.
+
+    The function assumes that the width and height are both greater than 1. This makes the function
+    deal with many possible shapes of depth images and intrinsics matrices.
+
+    .. note::
+        If :attr:`is_ortho` is False, the input depth images are transformed to orthogonal depth images
+        by using the :meth:`orthogonalize_perspective_depth` method.
+
+    Args:
+        depth: The depth measurement. Shape is (H, W) or or (H, W, 1) or (N, H, W) or (N, H, W, 1).
+        intrinsics: The camera's calibration matrix. If a single matrix is provided, the same
+            calibration matrix is used across all the depth images in the batch.
+            Shape is (3, 3) or (N, 3, 3).
+        is_ortho: Whether the input depth image is orthogonal or perspective depth image. If True, the input
+            depth image is considered as the *orthogonal* type, where the measurements are from the camera's
+            image plane. If False, the depth image is considered as the *perspective* type, where the
+            measurements are from the camera's optical center. Defaults to True.
+
+    Returns:
+        The 3D coordinates of points. Shape is (P, 3) or (N, P, 3).
+
+    Raises:
+        ValueError: When depth is not of shape (H, W) or (H, W, 1) or (N, H, W) or (N, H, W, 1).
+        ValueError: When intrinsics is not of shape (3, 3) or (N, 3, 3).
+    """
+    # clone inputs to avoid in-place modifications
+    intrinsics_batch = intrinsics.clone()
+    # convert depth image to orthogonal if needed
+    if not is_ortho:
+        depth_batch = orthogonalize_perspective_depth(depth, intrinsics)
+    else:
+        depth_batch = depth.clone()
+
+    # check if inputs are batched
+    is_batched = depth_batch.dim() == 4 or (depth_batch.dim() == 3 and depth_batch.shape[-1] != 1)
+    # make sure inputs are batched
+    if depth_batch.dim() == 3 and depth_batch.shape[-1] == 1:
+        depth_batch = depth_batch.squeeze(dim=2)  # (H, W, 1) -> (H, W)
+    if depth_batch.dim() == 2:
+        depth_batch = depth_batch[None]  # (H, W) -> (1, H, W)
+    if depth_batch.dim() == 4 and depth_batch.shape[-1] == 1:
+        depth_batch = depth_batch.squeeze(dim=3)  # (N, H, W, 1) -> (N, H, W)
+    if intrinsics_batch.dim() == 2:
+        intrinsics_batch = intrinsics_batch[None]  # (3, 3) -> (1, 3, 3)
+    # check shape of inputs
+    if depth_batch.dim() != 3:
+        raise ValueError(f"Expected depth images to have dim = 2 or 3 or 4: got shape {depth.shape}")
+    if intrinsics_batch.dim() != 3:
+        raise ValueError(f"Expected intrinsics to have shape (3, 3) or (N, 3, 3): got shape {intrinsics.shape}")
+
+    # get image height and width
+    im_height, im_width = depth_batch.shape[1:]
+    # create image points in homogeneous coordinates (3, H x W)
+    indices_u = torch.arange(im_width, device=depth.device, dtype=depth.dtype)
+    indices_v = torch.arange(im_height, device=depth.device, dtype=depth.dtype)
+    img_indices = torch.stack(torch.meshgrid([indices_u, indices_v], indexing="ij"), dim=0).reshape(2, -1)
+    pixels = torch.nn.functional.pad(img_indices, (0, 0, 0, 1), mode="constant", value=1.0)
+    pixels = pixels.unsqueeze(0)  # (3, H x W) -> (1, 3, H x W)
+
+    # unproject points into 3D space
+    points = torch.matmul(torch.inverse(intrinsics_batch), pixels)  # (N, 3, H x W)
+    points = points / points[:, -1, :].unsqueeze(1)  # normalize by last coordinate
+    # flatten depth image (N, H, W) -> (N, H x W)
+    depth_batch = depth_batch.transpose_(1, 2).reshape(depth_batch.shape[0], -1).unsqueeze(2)
+    depth_batch = depth_batch.expand(-1, -1, 3)
+    # scale points by depth
+    points_xyz = points.transpose_(1, 2) * depth_batch  # (N, H x W, 3)
+
+    # return points in same shape as input
+    if not is_batched:
+        points_xyz = points_xyz.squeeze(0)
+
+    return points_xyz
+
+
+@torch.jit.script
+def project_points(points: torch.Tensor, intrinsics: torch.Tensor) -> torch.Tensor:
+    r"""Projects 3D points into 2D image plane.
+
+    This project 3D points into a 2D image plane. The transformation is defined by the intrinsic
+    matrix of the camera.
+
+    .. math::
+
+        \begin{align}
+            p &= K \times p_{3D}  = \\
+            p_{2D} &= \begin{pmatrix} u \\ v \\  d \end{pmatrix}
+                    = \begin{pmatrix} p[0] / p[2] \\  p[1] / p[2] \\ Z \end{pmatrix}
+        \end{align}
+
+    where :math:`p_{2D} = (u, v, d)` is the projected 3D point, :math:`p_{3D} = (X, Y, Z)` is the
+    3D point and :math:`K \in \mathbb{R}^{3 \times 3}` is the intrinsic matrix.
+
+    If `points` is a batch of 3D points and `intrinsics` is a single intrinsic matrix, the same
+    calibration matrix is applied to all points in the batch.
+
+    Args:
+        points: The 3D coordinates of points. Shape is (P, 3) or (N, P, 3).
+        intrinsics: Camera's calibration matrix. Shape is (3, 3) or (N, 3, 3).
+
+    Returns:
+        Projected 3D coordinates of points. Shape is (P, 3) or (N, P, 3).
+    """
+    # clone the inputs to avoid in-place operations modifying the original data
+    points_batch = points.clone()
+    intrinsics_batch = intrinsics.clone()
+
+    # check if inputs are batched
+    is_batched = points_batch.dim() == 2
+    # make sure inputs are batched
+    if points_batch.dim() == 2:
+        points_batch = points_batch[None]  # (P, 3) -> (1, P, 3)
+    if intrinsics_batch.dim() == 2:
+        intrinsics_batch = intrinsics_batch[None]  # (3, 3) -> (1, 3, 3)
+    # check shape of inputs
+    if points_batch.dim() != 3:
+        raise ValueError(f"Expected points to have dim = 3: got shape {points.shape}.")
+    if intrinsics_batch.dim() != 3:
+        raise ValueError(f"Expected intrinsics to have shape (3, 3) or (N, 3, 3): got shape {intrinsics.shape}.")
+
+    # project points into 2D image plane
+    points_2d = torch.matmul(intrinsics_batch, points_batch.transpose(1, 2))
+    points_2d = points_2d / points_2d[:, -1, :].unsqueeze(1)  # normalize by last coordinate
+    points_2d = points_2d.transpose_(1, 2)  # (N, 3, P) -> (N, P, 3)
+    # replace last coordinate with depth
+    points_2d[:, :, -1] = points_batch[:, :, -1]
+
+    # return points in same shape as input
+    if not is_batched:
+        points_2d = points_2d.squeeze(0)  # (1, 3, P) -> (3, P)
+
+    return points_2d
+
+
+"""
+Sampling
+"""
+
+
+@torch.jit.script
+def default_orientation(num: int, device: str) -> torch.Tensor:
+    """Returns identity rotation transform.
+
+    Args:
+        num: The number of rotations to sample.
+        device: Device to create tensor on.
+
+    Returns:
+        Identity quaternion in (w, x, y, z). Shape is (num, 4).
+    """
+    quat = torch.zeros((num, 4), dtype=torch.float, device=device)
+    quat[..., 0] = 1.0
+
+    return quat
+
+
+@torch.jit.script
+def random_orientation(num: int, device: str) -> torch.Tensor:
+    """Returns sampled rotation in 3D as quaternion.
+
+    Args:
+        num: The number of rotations to sample.
+        device: Device to create tensor on.
+
+    Returns:
+        Sampled quaternion in (w, x, y, z). Shape is (num, 4).
+
+    Reference:
+        https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.transform.Rotation.random.html
+    """
+    # sample random orientation from normal distribution
+    quat = torch.randn((num, 4), dtype=torch.float, device=device)
+    # normalize the quaternion
+    return torch.nn.functional.normalize(quat, p=2.0, dim=-1, eps=1e-12)
+
+
+@torch.jit.script
+def random_yaw_orientation(num: int, device: str) -> torch.Tensor:
+    """Returns sampled rotation around z-axis.
+
+    Args:
+        num: The number of rotations to sample.
+        device: Device to create tensor on.
+
+    Returns:
+        Sampled quaternion in (w, x, y, z). Shape is (num, 4).
+    """
+    roll = torch.zeros(num, dtype=torch.float, device=device)
+    pitch = torch.zeros(num, dtype=torch.float, device=device)
+    yaw = 2 * torch.pi * torch.rand(num, dtype=torch.float, device=device)
+
+    return quat_from_euler_xyz(roll, pitch, yaw)
+
+
+def sample_triangle(lower: float, upper: float, size: int | tuple[int, ...], device: str) -> torch.Tensor:
+    """Randomly samples tensor from a triangular distribution.
+
+    Args:
+        lower: The lower range of the sampled tensor.
+        upper: The upper range of the sampled tensor.
+        size: The shape of the tensor.
+        device: Device to create tensor on.
+
+    Returns:
+        Sampled tensor. Shape is based on :attr:`size`.
+    """
+    # convert to tuple
+    if isinstance(size, int):
+        size = (size,)
+    # create random tensor in the range [-1, 1]
+    r = 2 * torch.rand(*size, device=device) - 1
+    # convert to triangular distribution
+    r = torch.where(r < 0.0, -torch.sqrt(-r), torch.sqrt(r))
+    # rescale back to [0, 1]
+    r = (r + 1.0) / 2.0
+    # rescale to range [lower, upper]
+    return (upper - lower) * r + lower
+
+
+def sample_uniform(
+    lower: torch.Tensor | float, upper: torch.Tensor | float, size: int | tuple[int, ...], device: str
+) -> torch.Tensor:
+    """Sample uniformly within a range.
+
+    Args:
+        lower: Lower bound of uniform range.
+        upper: Upper bound of uniform range.
+        size: The shape of the tensor.
+        device: Device to create tensor on.
+
+    Returns:
+        Sampled tensor. Shape is based on :attr:`size`.
+    """
+    # convert to tuple
+    if isinstance(size, int):
+        size = (size,)
+    # return tensor
+    return torch.rand(*size, device=device) * (upper - lower) + lower
+
+
+def sample_log_uniform(
+    lower: torch.Tensor | float, upper: torch.Tensor | float, size: int | tuple[int, ...], device: str
+) -> torch.Tensor:
+    r"""Sample using log-uniform distribution within a range.
+
+    The log-uniform distribution is defined as a uniform distribution in the log-space. It
+    is useful for sampling values that span several orders of magnitude. The sampled values
+    are uniformly distributed in the log-space and then exponentiated to get the final values.
+
+    .. math::
+
+        x = \exp(\text{uniform}(\log(\text{lower}), \log(\text{upper})))
+
+    Args:
+        lower: Lower bound of uniform range.
+        upper: Upper bound of uniform range.
+        size: The shape of the tensor.
+        device: Device to create tensor on.
+
+    Returns:
+        Sampled tensor. Shape is based on :attr:`size`.
+    """
+    # cast to tensor if not already
+    if not isinstance(lower, torch.Tensor):
+        lower = torch.tensor(lower, dtype=torch.float, device=device)
+    if not isinstance(upper, torch.Tensor):
+        upper = torch.tensor(upper, dtype=torch.float, device=device)
+    # sample in log-space and exponentiate
+    return torch.exp(sample_uniform(torch.log(lower), torch.log(upper), size, device))
+
+
+def sample_gaussian(
+    mean: torch.Tensor | float, std: torch.Tensor | float, size: int | tuple[int, ...], device: str
+) -> torch.Tensor:
+    """Sample using gaussian distribution.
+
+    Args:
+        mean: Mean of the gaussian.
+        std: Std of the gaussian.
+        size: The shape of the tensor.
+        device: Device to create tensor on.
+
+    Returns:
+        Sampled tensor.
+    """
+    if isinstance(mean, float):
+        if isinstance(size, int):
+            size = (size,)
+        return torch.normal(mean=mean, std=std, size=size).to(device=device)
+    else:
+        return torch.normal(mean=mean, std=std).to(device=device)
+
+
+def sample_cylinder(
+    radius: float, h_range: tuple[float, float], size: int | tuple[int, ...], device: str
+) -> torch.Tensor:
+    """Sample 3D points uniformly on a cylinder's surface.
+
+    The cylinder is centered at the origin and aligned with the z-axis. The height of the cylinder is
+    sampled uniformly from the range :obj:`h_range`, while the radius is fixed to :obj:`radius`.
+
+    The sampled points are returned as a tensor of shape :obj:`(*size, 3)`, i.e. the last dimension
+    contains the x, y, and z coordinates of the sampled points.
+
+    Args:
+        radius: The radius of the cylinder.
+        h_range: The minimum and maximum height of the cylinder.
+        size: The shape of the tensor.
+        device: Device to create tensor on.
+
+    Returns:
+        Sampled tensor. Shape is :obj:`(*size, 3)`.
+    """
+    # sample angles
+    angles = (torch.rand(size, device=device) * 2 - 1) * torch.pi
+    h_min, h_max = h_range
+    # add shape
+    if isinstance(size, int):
+        size = (size, 3)
+    else:
+        size += (3,)
+    # allocate a tensor
+    xyz = torch.zeros(size, device=device)
+    xyz[..., 0] = radius * torch.cos(angles)
+    xyz[..., 1] = radius * torch.sin(angles)
+    xyz[..., 2].uniform_(h_min, h_max)
+    # return positions
+    return xyz
+
+
+"""
+Orientation Conversions
+"""
+
+
+def convert_camera_frame_orientation_convention(
+    orientation: torch.Tensor,
+    origin: Literal["opengl", "ros", "world"] = "opengl",
+    target: Literal["opengl", "ros", "world"] = "ros",
+) -> torch.Tensor:
+    r"""Converts a quaternion representing a rotation from one convention to another.
+
+    In USD, the camera follows the ``"opengl"`` convention. Thus, it is always in **Y up** convention.
+    This means that the camera is looking down the -Z axis with the +Y axis pointing up , and +X axis pointing right.
+    However, in ROS, the camera is looking down the +Z axis with the +Y axis pointing down, and +X axis pointing right.
+    Thus, the camera needs to be rotated by :math:`180^{\circ}` around the X axis to follow the ROS convention.
+
+    .. math::
+
+        T_{ROS} = \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & -1 & 0 & 0 \\ 0 & 0 & -1 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} T_{USD}
+
+    On the other hand, the typical world coordinate system is with +X pointing forward, +Y pointing left,
+    and +Z pointing up. The camera can also be set in this convention by rotating the camera by :math:`90^{\circ}`
+    around the X axis and :math:`-90^{\circ}` around the Y axis.
+
+    .. math::
+
+        T_{WORLD} = \begin{bmatrix} 0 & 0 & -1 & 0 \\ -1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} T_{USD}
+
+    Thus, based on their application, cameras follow different conventions for their orientation. This function
+    converts a quaternion from one convention to another.
+
+    Possible conventions are:
+
+    - :obj:`"opengl"` - forward axis: -Z - up axis +Y - Offset is applied in the OpenGL (Usd.Camera) convention
+    - :obj:`"ros"`    - forward axis: +Z - up axis -Y - Offset is applied in the ROS convention
+    - :obj:`"world"`  - forward axis: +X - up axis +Z - Offset is applied in the World Frame convention
+
+    Args:
+        orientation: Quaternion of form `(w, x, y, z)` with shape (..., 4) in source convention.
+        origin: Convention to convert from. Defaults to "opengl".
+        target: Convention to convert to. Defaults to "ros".
+
+    Returns:
+        Quaternion of form `(w, x, y, z)` with shape (..., 4) in target convention
+    """
+    if target == origin:
+        return orientation.clone()
+
+    # -- unify input type
+    if origin == "ros":
+        # convert from ros to opengl convention
+        rotm = matrix_from_quat(orientation)
+        rotm[:, :, 2] = -rotm[:, :, 2]
+        rotm[:, :, 1] = -rotm[:, :, 1]
+        # convert to opengl convention
+        quat_gl = quat_from_matrix(rotm)
+    elif origin == "world":
+        # convert from world (x forward and z up) to opengl convention
+        rotm = matrix_from_quat(orientation)
+        rotm = torch.matmul(
+            rotm,
+            matrix_from_euler(torch.tensor([math.pi / 2, -math.pi / 2, 0], device=orientation.device), "XYZ"),
+        )
+        # convert to isaac-sim convention
+        quat_gl = quat_from_matrix(rotm)
+    else:
+        quat_gl = orientation
+
+    # -- convert to target convention
+    if target == "ros":
+        # convert from opengl to ros convention
+        rotm = matrix_from_quat(quat_gl)
+        rotm[:, :, 2] = -rotm[:, :, 2]
+        rotm[:, :, 1] = -rotm[:, :, 1]
+        return quat_from_matrix(rotm)
+    elif target == "world":
+        # convert from opengl to world (x forward and z up) convention
+        rotm = matrix_from_quat(quat_gl)
+        rotm = torch.matmul(
+            rotm,
+            matrix_from_euler(torch.tensor([math.pi / 2, -math.pi / 2, 0], device=orientation.device), "XYZ").T,
+        )
+        return quat_from_matrix(rotm)
+    else:
+        return quat_gl.clone()
+
+
+def create_rotation_matrix_from_view(
+    eyes: torch.Tensor,
+    targets: torch.Tensor,
+    up_axis: Literal["Y", "Z"] = "Z",
+    device: str = "cpu",
+) -> torch.Tensor:
+    """Compute the rotation matrix from world to view coordinates.
+
+    This function takes a vector ''eyes'' which specifies the location
+    of the camera in world coordinates and the vector ''targets'' which
+    indicate the position of the object.
+    The output is a rotation matrix representing the transformation
+    from world coordinates -> view coordinates.
+
+        The inputs eyes and targets can each be a
+        - 3 element tuple/list
+        - torch tensor of shape (1, 3)
+        - torch tensor of shape (N, 3)
+
+    Args:
+        eyes: Position of the camera in world coordinates.
+        targets: Position of the object in world coordinates.
+        up_axis: The up axis of the camera. Defaults to "Z".
+        device: The device to create torch tensors on. Defaults to "cpu".
+
+    The vectors are broadcast against each other so they all have shape (N, 3).
+
+    Returns:
+        R: (N, 3, 3) batched rotation matrices
+
+    Reference:
+    Based on PyTorch3D (https://github.com/facebookresearch/pytorch3d/blob/eaf0709d6af0025fe94d1ee7cec454bc3054826a/pytorch3d/renderer/cameras.py#L1635-L1685)
+    """
+    if up_axis == "Y":
+        up_axis_vec = torch.tensor((0, 1, 0), device=device, dtype=torch.float32).repeat(eyes.shape[0], 1)
+    elif up_axis == "Z":
+        up_axis_vec = torch.tensor((0, 0, 1), device=device, dtype=torch.float32).repeat(eyes.shape[0], 1)
+    else:
+        raise ValueError(f"Invalid up axis: {up_axis}. Valid options are 'Y' and 'Z'.")
+
+    # get rotation matrix in opengl format (-Z forward, +Y up)
+    z_axis = -torch.nn.functional.normalize(targets - eyes, eps=1e-5)
+    x_axis = torch.nn.functional.normalize(torch.cross(up_axis_vec, z_axis, dim=1), eps=1e-5)
+    y_axis = torch.nn.functional.normalize(torch.cross(z_axis, x_axis, dim=1), eps=1e-5)
+    is_close = torch.isclose(x_axis, torch.tensor(0.0), atol=5e-3).all(dim=1, keepdim=True)
+    if is_close.any():
+        replacement = torch.nn.functional.normalize(torch.cross(y_axis, z_axis, dim=1), eps=1e-5)
+        x_axis = torch.where(is_close, replacement, x_axis)
+    R = torch.cat((x_axis[:, None, :], y_axis[:, None, :], z_axis[:, None, :]), dim=1)
+    return R.transpose(1, 2)
+
+
+def make_pose(pos: torch.Tensor, rot: torch.Tensor) -> torch.Tensor:
+    """Creates transformation matrices from positions and rotation matrices.
+
+    Args:
+        pos: Batch of position vectors with last dimension of 3.
+        rot: Batch of rotation matrices with last 2 dimensions of (3, 3).
+
+    Returns:
+        Batch of pose matrices with last 2 dimensions of (4, 4).
+    """
+    assert isinstance(pos, torch.Tensor), "Input must be a torch tensor"
+    assert isinstance(rot, torch.Tensor), "Input must be a torch tensor"
+    assert pos.shape[:-1] == rot.shape[:-2]
+    assert pos.shape[-1] == rot.shape[-2] == rot.shape[-1] == 3
+    pose = torch.zeros(pos.shape[:-1] + (4, 4), dtype=pos.dtype, device=pos.device)
+    pose[..., :3, :3] = rot
+    pose[..., :3, 3] = pos
+    pose[..., 3, 3] = 1.0
+    return pose
+
+
+def unmake_pose(pose: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+    """Splits transformation matrices into positions and rotation matrices.
+
+    Args:
+        pose: Batch of pose matrices with last 2 dimensions of (4, 4).
+
+    Returns:
+        Tuple containing:
+            - Batch of position vectors with last dimension of 3.
+            - Batch of rotation matrices with last 2 dimensions of (3, 3).
+    """
+    assert isinstance(pose, torch.Tensor), "Input must be a torch tensor"
+    return pose[..., :3, 3], pose[..., :3, :3]
+
+
+def pose_inv(pose: torch.Tensor) -> torch.Tensor:
+    """Computes the inverse of transformation matrices.
+
+    The inverse of a pose matrix [R t; 0 1] is [R.T -R.T*t; 0 1].
+
+    Args:
+        pose: Batch of pose matrices with last 2 dimensions of (4, 4).
+
+    Returns:
+        Batch of inverse pose matrices with last 2 dimensions of (4, 4).
+    """
+    assert isinstance(pose, torch.Tensor), "Input must be a torch tensor"
+    num_axes = len(pose.shape)
+    assert num_axes >= 2
+
+    inv_pose = torch.zeros_like(pose)
+
+    # Take transpose of last 2 dimensions
+    inv_pose[..., :3, :3] = pose[..., :3, :3].transpose(-1, -2)
+
+    # note: PyTorch matmul wants shapes [..., 3, 3] x [..., 3, 1] -> [..., 3, 1] so we add a dimension and take it away after
+    inv_pose[..., :3, 3] = torch.matmul(-inv_pose[..., :3, :3], pose[..., :3, 3:4])[..., 0]
+    inv_pose[..., 3, 3] = 1.0
+    return inv_pose
+
+
+def pose_in_A_to_pose_in_B(pose_in_A: torch.Tensor, pose_A_in_B: torch.Tensor) -> torch.Tensor:
+    """Converts poses from one coordinate frame to another.
+
+    Transforms matrices representing point C in frame A
+    to matrices representing the same point C in frame B.
+
+    Example usage:
+
+    frame_C_in_B = pose_in_A_to_pose_in_B(frame_C_in_A, frame_A_in_B)
+
+    Args:
+        pose_in_A: Batch of transformation matrices of point C in frame A.
+        pose_A_in_B: Batch of transformation matrices of frame A in frame B.
+
+    Returns:
+        Batch of transformation matrices of point C in frame B.
+    """
+    assert isinstance(pose_in_A, torch.Tensor), "Input must be a torch tensor"
+    assert isinstance(pose_A_in_B, torch.Tensor), "Input must be a torch tensor"
+    return torch.matmul(pose_A_in_B, pose_in_A)
+
+
+def quat_slerp(q1: torch.Tensor, q2: torch.Tensor, tau: float) -> torch.Tensor:
+    """Performs spherical linear interpolation (SLERP) between two quaternions.
+
+    This function does not support batch processing.
+
+    Args:
+        q1: First quaternion in (w, x, y, z) format.
+        q2: Second quaternion in (w, x, y, z) format.
+        tau: Interpolation coefficient between 0 (q1) and 1 (q2).
+
+    Returns:
+        Interpolated quaternion in (w, x, y, z) format.
+    """
+    assert isinstance(q1, torch.Tensor), "Input must be a torch tensor"
+    assert isinstance(q2, torch.Tensor), "Input must be a torch tensor"
+    if tau == 0.0:
+        return q1
+    elif tau == 1.0:
+        return q2
+    d = torch.dot(q1, q2)
+    if abs(abs(d) - 1.0) < torch.finfo(q1.dtype).eps * 4.0:
+        return q1
+    if d < 0.0:
+        # Invert rotation
+        d = -d
+        q2 *= -1.0
+    angle = torch.acos(torch.clamp(d, -1, 1))
+    if abs(angle) < torch.finfo(q1.dtype).eps * 4.0:
+        return q1
+    isin = 1.0 / torch.sin(angle)
+    q1 = q1 * torch.sin((1.0 - tau) * angle) * isin
+    q2 = q2 * torch.sin(tau * angle) * isin
+    q1 = q1 + q2
+    return q1
+
+
+def interpolate_rotations(R1: torch.Tensor, R2: torch.Tensor, num_steps: int, axis_angle: bool = True) -> torch.Tensor:
+    """Interpolates between two rotation matrices.
+
+    Args:
+        R1: First rotation matrix. (4x4).
+        R2: Second rotation matrix. (4x4).
+        num_steps: Number of desired interpolated rotations (excluding start and end).
+        axis_angle: If True, interpolate in axis-angle representation;
+                   otherwise use slerp. Defaults to True.
+
+    Returns:
+        Stack of interpolated rotation matrices of shape (num_steps + 1, 4, 4),
+        including the start and end rotations.
+    """
+    assert isinstance(R1, torch.Tensor), "Input must be a torch tensor"
+    assert isinstance(R2, torch.Tensor), "Input must be a torch tensor"
+    if axis_angle:
+        # Delta rotation expressed as axis-angle
+        delta_rot_mat = torch.matmul(R2, R1.transpose(-1, -2))
+        delta_quat = quat_from_matrix(delta_rot_mat)
+        delta_axis_angle = axis_angle_from_quat(delta_quat)
+
+        # Grab angle
+        delta_angle = torch.linalg.norm(delta_axis_angle)
+
+        # Fix the axis, and chunk the angle up into steps
+        rot_step_size = delta_angle / num_steps
+
+        # Convert into delta rotation matrices, and then convert to absolute rotations
+        if delta_angle < 0.05:
+            # Small angle - don't bother with interpolation
+            rot_steps = torch.stack([R2 for _ in range(num_steps)])
+        else:
+            # Make sure that axis is a unit vector
+            delta_axis = delta_axis_angle / delta_angle
+            delta_rot_steps = [
+                matrix_from_quat(quat_from_angle_axis(i * rot_step_size, delta_axis)) for i in range(num_steps)
+            ]
+            rot_steps = torch.stack([torch.matmul(delta_rot_steps[i], R1) for i in range(num_steps)])
+    else:
+        q1 = quat_from_matrix(R1)
+        q2 = quat_from_matrix(R2)
+        rot_steps = torch.stack(
+            [matrix_from_quat(quat_slerp(q1, q2, tau=float(i) / num_steps)) for i in range(num_steps)]
+        )
+
+    # Add in endpoint
+    rot_steps = torch.cat([rot_steps, R2[None]], dim=0)
+
+    return rot_steps
+
+
+def interpolate_poses(
+    pose_1: torch.Tensor,
+    pose_2: torch.Tensor,
+    num_steps: int = None,
+    step_size: float = None,
+    perturb: bool = False,
+) -> tuple[torch.Tensor, int]:
+    """Performs linear interpolation between two poses.
+
+    Args:
+        pose_1: 4x4 start pose.
+        pose_2: 4x4 end pose.
+        num_steps: If provided, specifies the number of desired interpolated points.
+                  Passing 0 corresponds to no interpolation. If None, step_size must be provided.
+        step_size: If provided, determines number of steps based on distance between poses.
+        perturb: If True, randomly perturbs interpolated position points.
+
+    Returns:
+        Tuple containing:
+            - Array of shape (N + 2, 4, 4) corresponding to the interpolated pose path.
+            - Number of interpolated points (N) in the path.
+    """
+    assert isinstance(pose_1, torch.Tensor), "Input must be a torch tensor"
+    assert isinstance(pose_2, torch.Tensor), "Input must be a torch tensor"
+    assert step_size is None or num_steps is None
+
+    pos1, rot1 = unmake_pose(pose_1)
+    pos2, rot2 = unmake_pose(pose_2)
+
+    if num_steps == 0:
+        # Skip interpolation
+        return (
+            torch.cat([pos1[None], pos2[None]], dim=0),
+            torch.cat([rot1[None], rot2[None]], dim=0),
+            num_steps,
+        )
+
+    delta_pos = pos2 - pos1
+    if num_steps is None:
+        assert torch.norm(delta_pos) > 0
+        num_steps = math.ceil(torch.norm(delta_pos) / step_size)
+
+    num_steps += 1  # Include starting pose
+    assert num_steps >= 2
+
+    # Linear interpolation of positions
+    pos_step_size = delta_pos / num_steps
+    grid = torch.arange(num_steps, dtype=torch.float32)
+    if perturb:
+        # Move interpolation grid points by up to half-size forward or backward
+        perturbations = torch.rand(num_steps - 2) - 0.5
+        grid[1:-1] += perturbations
+    pos_steps = torch.stack([pos1 + grid[i] * pos_step_size for i in range(num_steps)])
+
+    # Add in endpoint
+    pos_steps = torch.cat([pos_steps, pos2[None]], dim=0)
+
+    # Interpolate rotations
+    rot_steps = interpolate_rotations(R1=rot1, R2=rot2, num_steps=num_steps, axis_angle=True)
+
+    pose_steps = make_pose(pos_steps, rot_steps)
+    return pose_steps, num_steps - 1
+
+
+def transform_poses_from_frame_A_to_frame_B(
+    src_poses: torch.Tensor, frame_A: torch.Tensor, frame_B: torch.Tensor
+) -> torch.Tensor:
+    """Transforms poses from one coordinate frame to another preserving relative poses.
+
+    Args:
+        src_poses: Input pose sequence (shape [T, 4, 4]) from source demonstration.
+        frame_A: 4x4 frame A pose.
+        frame_B: 4x4 frame B pose.
+
+    Returns:
+        Transformed pose sequence of shape [T, 4, 4].
+    """
+    # Transform source end effector poses to be relative to source object frame
+    src_poses_rel_frame_B = pose_in_A_to_pose_in_B(
+        pose_in_A=src_poses,
+        pose_A_in_B=pose_inv(frame_B[None]),
+    )
+
+    # Apply relative poses to current object frame to obtain new target eef poses
+    transformed_poses = pose_in_A_to_pose_in_B(
+        pose_in_A=src_poses_rel_frame_B,
+        pose_A_in_B=frame_A[None],
+    )
+    return transformed_poses
+
+
+def generate_random_rotation(rot_boundary: float = (2 * math.pi)) -> torch.Tensor:
+    """Generates a random rotation matrix using Euler angles.
+
+    Args:
+        rot_boundary: Range for random rotation angles around each axis (x, y, z).
+
+    Returns:
+        3x3 rotation matrix.
+    """
+    angles = torch.rand(3) * rot_boundary
+    Rx = torch.tensor(
+        [[1, 0, 0], [0, torch.cos(angles[0]), -torch.sin(angles[0])], [0, torch.sin(angles[0]), torch.cos(angles[0])]]
+    )
+
+    Ry = torch.tensor(
+        [[torch.cos(angles[1]), 0, torch.sin(angles[1])], [0, 1, 0], [-torch.sin(angles[1]), 0, torch.cos(angles[1])]]
+    )
+
+    Rz = torch.tensor(
+        [[torch.cos(angles[2]), -torch.sin(angles[2]), 0], [torch.sin(angles[2]), torch.cos(angles[2]), 0], [0, 0, 1]]
+    )
+
+    # Combined rotation matrix
+    R = torch.matmul(torch.matmul(Rz, Ry), Rx)
+    return R
+
+
+def generate_random_translation(pos_boundary: float = 1) -> torch.Tensor:
+    """Generates a random translation vector.
+
+    Args:
+        pos_boundary: Range for random translation values in 3D space.
+
+    Returns:
+        3-element translation vector.
+    """
+    return torch.rand(3) * 2 * pos_boundary - pos_boundary  # Random translation in 3D space
+
+
+def generate_random_transformation_matrix(pos_boundary: float = 1, rot_boundary: float = (2 * math.pi)) -> torch.Tensor:
+    """Generates a random transformation matrix combining rotation and translation.
+
+    Args:
+        pos_boundary: Range for random translation values.
+        rot_boundary: Range for random rotation angles.
+
+    Returns:
+        4x4 transformation matrix.
+    """
+    R = generate_random_rotation(rot_boundary)
+    translation = generate_random_translation(pos_boundary)
+
+    # Create the transformation matrix
+    T = torch.eye(4)
+    T[:3, :3] = R
+    T[:3, 3] = translation
+
+    return T
diff --git a/src/mjlab/utils/lab_api/string.py b/src/mjlab/utils/lab_api/string.py
new file mode 100644
index 0000000..d9b44a4
--- /dev/null
+++ b/src/mjlab/utils/lab_api/string.py
@@ -0,0 +1,368 @@
+# Copyright (c) 2022-2025, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Sub-module containing utilities for transforming strings and regular expressions."""
+
+import ast
+import importlib
+import inspect
+import re
+from collections.abc import Callable, Sequence
+from typing import Any
+
+"""
+String formatting.
+"""
+
+
+def to_camel_case(snake_str: str, to: str = "cC") -> str:
+    """Converts a string from snake case to camel case.
+
+    Args:
+        snake_str: A string in snake case (i.e. with '_')
+        to: Convention to convert string to. Defaults to "cC".
+
+    Raises:
+        ValueError: Invalid input argument `to`, i.e. not "cC" or "CC".
+
+    Returns:
+        A string in camel-case format.
+    """
+    # check input is correct
+    if to not in ["cC", "CC"]:
+        msg = "to_camel_case(): Choose a valid `to` argument (CC or cC)"
+        raise ValueError(msg)
+    # convert string to lower case and split
+    components = snake_str.lower().split("_")
+    if to == "cC":
+        # We capitalize the first letter of each component except the first one
+        # with the 'title' method and join them together.
+        return components[0] + "".join(x.title() for x in components[1:])
+    else:
+        # Capitalize first letter in all the components
+        return "".join(x.title() for x in components)
+
+
+def to_snake_case(camel_str: str) -> str:
+    """Converts a string from camel case to snake case.
+
+    Args:
+        camel_str: A string in camel case.
+
+    Returns:
+        A string in snake case (i.e. with '_')
+    """
+    camel_str = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", camel_str)
+    return re.sub("([a-z0-9])([A-Z])", r"\1_\2", camel_str).lower()
+
+
+def string_to_slice(s: str):
+    """Convert a string representation of a slice to a slice object.
+
+    Args:
+        s: The string representation of the slice.
+
+    Returns:
+        The slice object.
+    """
+    # extract the content inside the slice()
+    match = re.match(r"slice\((.*),(.*),(.*)\)", s)
+    if not match:
+        raise ValueError(f"Invalid slice string format: {s}")
+
+    # extract start, stop, and step values
+    start_str, stop_str, step_str = match.groups()
+
+    # convert 'None' to None and other strings to integers
+    start = None if start_str == "None" else int(start_str)
+    stop = None if stop_str == "None" else int(stop_str)
+    step = None if step_str == "None" else int(step_str)
+
+    # create and return the slice object
+    return slice(start, stop, step)
+
+
+"""
+String <-> Callable operations.
+"""
+
+
+def is_lambda_expression(name: str) -> bool:
+    """Checks if the input string is a lambda expression.
+
+    Args:
+        name: The input string.
+
+    Returns:
+        Whether the input string is a lambda expression.
+    """
+    try:
+        ast.parse(name)
+        return isinstance(ast.parse(name).body[0], ast.Expr) and isinstance(ast.parse(name).body[0].value, ast.Lambda)
+    except SyntaxError:
+        return False
+
+
+def callable_to_string(value: Callable) -> str:
+    """Converts a callable object to a string.
+
+    Args:
+        value: A callable object.
+
+    Raises:
+        ValueError: When the input argument is not a callable object.
+
+    Returns:
+        A string representation of the callable object.
+    """
+    # check if callable
+    if not callable(value):
+        raise ValueError(f"The input argument is not callable: {value}.")
+    # check if lambda function
+    if value.__name__ == "<lambda>":
+        # we resolve the lambda expression by checking the source code and extracting the line with lambda expression
+        # we also remove any comments from the line
+        lambda_line = inspect.getsourcelines(value)[0][0].strip().split("lambda")[1].strip().split(",")[0]
+        lambda_line = re.sub(r"#.*$", "", lambda_line).rstrip()
+        return f"lambda {lambda_line}"
+    else:
+        # get the module and function name
+        module_name = value.__module__
+        function_name = value.__name__
+        # return the string
+        return f"{module_name}:{function_name}"
+
+
+def string_to_callable(name: str) -> Callable:
+    """Resolves the module and function names to return the function.
+
+    Args:
+        name: The function name. The format should be 'module:attribute_name' or a
+            lambda expression of format: 'lambda x: x'.
+
+    Raises:
+        ValueError: When the resolved attribute is not a function.
+        ValueError: When the module cannot be found.
+
+    Returns:
+        Callable: The function loaded from the module.
+    """
+    try:
+        if is_lambda_expression(name):
+            callable_object = eval(name)
+        else:
+            mod_name, attr_name = name.split(":")
+            mod = importlib.import_module(mod_name)
+            callable_object = getattr(mod, attr_name)
+        # check if attribute is callable
+        if callable(callable_object):
+            return callable_object
+        else:
+            raise AttributeError(f"The imported object is not callable: '{name}'")
+    except (ValueError, ModuleNotFoundError) as e:
+        msg = (
+            f"Could not resolve the input string '{name}' into callable object."
+            " The format of input should be 'module:attribute_name'.\n"
+            f"Received the error:\n {e}."
+        )
+        raise ValueError(msg)
+
+
+"""
+Regex operations.
+"""
+
+
+def resolve_matching_names(
+    keys: str | Sequence[str], list_of_strings: Sequence[str], preserve_order: bool = False
+) -> tuple[list[int], list[str]]:
+    """Match a list of query regular expressions against a list of strings and return the matched indices and names.
+
+    When a list of query regular expressions is provided, the function checks each target string against each
+    query regular expression and returns the indices of the matched strings and the matched strings.
+
+    If the :attr:`preserve_order` is True, the ordering of the matched indices and names follows the order
+    of the query regular expressions. This means that the ordering is dictated by the order of the query keys
+    and not the order of the target strings.
+
+    If the :attr:`preserve_order` is False, the ordering of the matched indices and names follows the order
+    of the target strings (i.e., the order in which they appear in :attr:`list_of_strings`).
+
+    For example, consider the list of strings is ['a', 'b', 'c', 'd', 'e'] and the regular expressions are ['a|c', 'b'].
+    If :attr:`preserve_order` is False, then the function will return the indices of the matched strings and the
+    strings as: ([0, 1, 2], ['a', 'b', 'c']). When :attr:`preserve_order` is True, it will return them as:
+    ([0, 2, 1], ['a', 'c', 'b']).
+
+    Note:
+        The function does not sort the indices. It returns the indices in the order they are found.
+
+    Args:
+        keys: A regular expression or a list of regular expressions to match the strings in the list.
+        list_of_strings: A list of strings to match.
+        preserve_order: Whether to preserve the order of the query keys in the returned values. Defaults to False.
+
+    Returns:
+        A tuple of lists containing the matched indices and names.
+
+    Raises:
+        ValueError: When multiple matches are found for a string in the list.
+        ValueError: When not all regular expressions are matched.
+    """
+    # resolve name keys
+    if isinstance(keys, str):
+        keys = [keys]
+    # find matching patterns
+    index_list = []
+    names_list = []
+    key_idx_list = []
+    # book-keeping to check that we always have a one-to-one mapping
+    # i.e. each target string should match only one regular expression
+    target_strings_match_found = [None for _ in range(len(list_of_strings))]
+    keys_match_found = [[] for _ in range(len(keys))]
+    # loop over all target strings
+    for target_index, potential_match_string in enumerate(list_of_strings):
+        for key_index, re_key in enumerate(keys):
+            if re.fullmatch(re_key, potential_match_string):
+                # check if match already found
+                if target_strings_match_found[target_index]:
+                    raise ValueError(
+                        f"Multiple matches for '{potential_match_string}':"
+                        f" '{target_strings_match_found[target_index]}' and '{re_key}'!"
+                    )
+                # add to list
+                target_strings_match_found[target_index] = re_key
+                index_list.append(target_index)
+                names_list.append(potential_match_string)
+                key_idx_list.append(key_index)
+                # add for regex key
+                keys_match_found[key_index].append(potential_match_string)
+    # reorder keys if they should be returned in order of the query keys
+    if preserve_order:
+        reordered_index_list = [None] * len(index_list)
+        global_index = 0
+        for key_index in range(len(keys)):
+            for key_idx_position, key_idx_entry in enumerate(key_idx_list):
+                if key_idx_entry == key_index:
+                    reordered_index_list[key_idx_position] = global_index
+                    global_index += 1
+        # reorder index and names list
+        index_list_reorder = [None] * len(index_list)
+        names_list_reorder = [None] * len(index_list)
+        for idx, reorder_idx in enumerate(reordered_index_list):
+            index_list_reorder[reorder_idx] = index_list[idx]
+            names_list_reorder[reorder_idx] = names_list[idx]
+        # update
+        index_list = index_list_reorder
+        names_list = names_list_reorder
+    # check that all regular expressions are matched
+    if not all(keys_match_found):
+        # make this print nicely aligned for debugging
+        msg = "\n"
+        for key, value in zip(keys, keys_match_found):
+            msg += f"\t{key}: {value}\n"
+        msg += f"Available strings: {list_of_strings}\n"
+        # raise error
+        raise ValueError(
+            f"Not all regular expressions are matched! Please check that the regular expressions are correct: {msg}"
+        )
+    # return
+    return index_list, names_list
+
+
+def resolve_matching_names_values(
+    data: dict[str, Any], list_of_strings: Sequence[str], preserve_order: bool = False
+) -> tuple[list[int], list[str], list[Any]]:
+    """Match a list of regular expressions in a dictionary against a list of strings and return
+    the matched indices, names, and values.
+
+    If the :attr:`preserve_order` is True, the ordering of the matched indices and names follows the order
+    of the query regular expressions. This means that the ordering is dictated by the order of the query keys
+    and not the order of the target strings.
+
+    If the :attr:`preserve_order` is False, the ordering of the matched indices and names follows the order
+    of the target strings (i.e., the order in which they appear in :attr:`list_of_strings`).
+
+    For example, consider the dictionary is {"a|d|e": 1, "b|c": 2}, the list of strings is ['a', 'b', 'c', 'd', 'e'].
+    If :attr:`preserve_order` is False, then the function will return the indices of the matched strings, the
+    matched strings, and the values as: ([0, 1, 2, 3, 4], ['a', 'b', 'c', 'd', 'e'], [1, 2, 2, 1, 1]). When
+    :attr:`preserve_order` is True, it will return them as: ([0, 3, 4, 1, 2], ['a', 'd', 'e', 'b', 'c'], [1, 1, 1, 2, 2]).
+
+    Args:
+        data: A dictionary of regular expressions and values to match the strings in the list.
+        list_of_strings: A list of strings to match.
+        preserve_order: Whether to preserve the order of the query keys in the returned values. Defaults to False.
+
+    Returns:
+        A tuple of lists containing the matched indices, names, and values.
+
+    Raises:
+        TypeError: When the input argument :attr:`data` is not a dictionary.
+        ValueError: When multiple matches are found for a string in the dictionary.
+        ValueError: When not all regular expressions in the data keys are matched.
+    """
+    # check valid input
+    if not isinstance(data, dict):
+        raise TypeError(f"Input argument `data` should be a dictionary. Received: {data}")
+    # find matching patterns
+    index_list = []
+    names_list = []
+    values_list = []
+    key_idx_list = []
+    # book-keeping to check that we always have a one-to-one mapping
+    # i.e. each target string should match only one regular expression
+    target_strings_match_found = [None for _ in range(len(list_of_strings))]
+    keys_match_found = [[] for _ in range(len(data))]
+    # loop over all target strings
+    for target_index, potential_match_string in enumerate(list_of_strings):
+        for key_index, (re_key, value) in enumerate(data.items()):
+            if re.fullmatch(re_key, potential_match_string):
+                # check if match already found
+                if target_strings_match_found[target_index]:
+                    raise ValueError(
+                        f"Multiple matches for '{potential_match_string}':"
+                        f" '{target_strings_match_found[target_index]}' and '{re_key}'!"
+                    )
+                # add to list
+                target_strings_match_found[target_index] = re_key
+                index_list.append(target_index)
+                names_list.append(potential_match_string)
+                values_list.append(value)
+                key_idx_list.append(key_index)
+                # add for regex key
+                keys_match_found[key_index].append(potential_match_string)
+    # reorder keys if they should be returned in order of the query keys
+    if preserve_order:
+        reordered_index_list = [None] * len(index_list)
+        global_index = 0
+        for key_index in range(len(data)):
+            for key_idx_position, key_idx_entry in enumerate(key_idx_list):
+                if key_idx_entry == key_index:
+                    reordered_index_list[key_idx_position] = global_index
+                    global_index += 1
+        # reorder index and names list
+        index_list_reorder = [None] * len(index_list)
+        names_list_reorder = [None] * len(index_list)
+        values_list_reorder = [None] * len(index_list)
+        for idx, reorder_idx in enumerate(reordered_index_list):
+            index_list_reorder[reorder_idx] = index_list[idx]
+            names_list_reorder[reorder_idx] = names_list[idx]
+            values_list_reorder[reorder_idx] = values_list[idx]
+        # update
+        index_list = index_list_reorder
+        names_list = names_list_reorder
+        values_list = values_list_reorder
+    # check that all regular expressions are matched
+    if not all(keys_match_found):
+        # make this print nicely aligned for debugging
+        msg = "\n"
+        for key, value in zip(data.keys(), keys_match_found):
+            msg += f"\t{key}: {value}\n"
+        msg += f"Available strings: {list_of_strings}\n"
+        # raise error
+        raise ValueError(
+            f"Not all regular expressions are matched! Please check that the regular expressions are correct: {msg}"
+        )
+    # return
+    return index_list, names_list, values_list
diff --git a/src/mjlab/utils/lab_api/tasks/importer.py b/src/mjlab/utils/lab_api/tasks/importer.py
new file mode 100644
index 0000000..c15bd3d
--- /dev/null
+++ b/src/mjlab/utils/lab_api/tasks/importer.py
@@ -0,0 +1,89 @@
+# Copyright (c) 2022-2025, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Sub-module with utility for importing all modules in a package recursively."""
+
+from __future__ import annotations
+
+import importlib
+import pkgutil
+import sys
+
+
+def import_packages(package_name: str, blacklist_pkgs: list[str] | None = None):
+  """Import all sub-packages in a package recursively.
+
+  It is easier to use this function to import all sub-packages in a package recursively
+  than to manually import each sub-package.
+
+  It replaces the need of the following code snippet on the top of each package's ``__init__.py`` file:
+
+  .. code-block:: python
+
+      import .locomotion.velocity
+      import .manipulation.reach
+      import .manipulation.lift
+
+  Args:
+      package_name: The package name.
+      blacklist_pkgs: The list of blacklisted packages to skip. Defaults to None,
+          which means no packages are blacklisted.
+  """
+  # Default blacklist
+  if blacklist_pkgs is None:
+    blacklist_pkgs = []
+  # Import the package itself
+  package = importlib.import_module(package_name)
+  # Import all Python files
+  for _ in _walk_packages(
+    package.__path__, package.__name__ + ".", blacklist_pkgs=blacklist_pkgs
+  ):
+    pass
+
+
+def _walk_packages(
+  path: str | None = None,
+  prefix: str = "",
+  onerror: callable | None = None,
+  blacklist_pkgs: list[str] | None = None,
+):
+  """Yields ModuleInfo for all modules recursively on path, or, if path is None, all accessible modules.
+
+  Note:
+      This function is a modified version of the original ``pkgutil.walk_packages`` function. It adds
+      the `blacklist_pkgs` argument to skip blacklisted packages. Please refer to the original
+      ``pkgutil.walk_packages`` function for more details.
+  """
+  if blacklist_pkgs is None:
+    blacklist_pkgs = []
+
+  def seen(p, m={}):
+    if p in m:
+      return True
+    m[p] = True  # noqa: R503
+
+  for info in pkgutil.iter_modules(path, prefix):
+    # check blacklisted
+    if any([black_pkg_name in info.name for black_pkg_name in blacklist_pkgs]):
+      continue
+
+    # yield the module info
+    yield info
+
+    if info.ispkg:
+      try:
+        __import__(info.name)
+      except Exception:
+        if onerror is not None:
+          onerror(info.name)
+        else:
+          raise
+      else:
+        path = getattr(sys.modules[info.name], "__path__", None) or []
+
+        # don't traverse path items we've seen before
+        path = [p for p in path if not seen(p)]
+
+        yield from _walk_packages(path, info.name + ".", onerror, blacklist_pkgs)
diff --git a/src/mjlab/utils/logging.py b/src/mjlab/utils/logging.py
new file mode 100644
index 0000000..c71f707
--- /dev/null
+++ b/src/mjlab/utils/logging.py
@@ -0,0 +1,25 @@
+"""Logging utilities for colored terminal output."""
+
+import sys
+
+
+def print_info(message: str, color: str = "green") -> None:
+  """Print information message with color.
+
+  Args:
+    message: The message to print.
+    color: Color name ('green', 'red', 'yellow', 'blue', 'cyan', 'magenta').
+  """
+  colors = {
+    "green": "\033[92m",
+    "red": "\033[91m",
+    "yellow": "\033[93m",
+    "blue": "\033[94m",
+    "cyan": "\033[96m",
+    "magenta": "\033[95m",
+  }
+
+  if sys.stdout.isatty() and color in colors:
+    print(f"{colors[color]}{message}\033[0m")
+  else:
+    print(message)
diff --git a/src/mjlab/utils/mujoco.py b/src/mjlab/utils/mujoco.py
new file mode 100644
index 0000000..899414a
--- /dev/null
+++ b/src/mjlab/utils/mujoco.py
@@ -0,0 +1,93 @@
+from collections.abc import Callable
+from typing import Literal
+
+import mujoco
+
+
+def is_position_actuator(actuator: mujoco.MjsActuator) -> bool:
+  """Check if an actuator is a position actuator.
+
+  Matches actuators created by ``MjsActuator.set_to_position()`` or
+  ``create_position_actuator()``.
+  """
+  return (
+    actuator.gaintype == mujoco.mjtGain.mjGAIN_FIXED
+    and actuator.biastype == mujoco.mjtBias.mjBIAS_AFFINE
+    and actuator.dyntype in (mujoco.mjtDyn.mjDYN_NONE, mujoco.mjtDyn.mjDYN_FILTEREXACT)
+    and actuator.gainprm[0] == -actuator.biasprm[1]
+  )
+
+
+def is_velocity_actuator(actuator: mujoco.MjsActuator) -> bool:
+  """Check if an actuator is a velocity actuator.
+
+    Matches actuators created by ``MjsActuator.set_to_velocity()`` or
+  ``create_velocity_actuator()``.
+  """
+  return (
+    actuator.gaintype == mujoco.mjtGain.mjGAIN_FIXED
+    and actuator.biastype == mujoco.mjtBias.mjBIAS_AFFINE
+    and actuator.dyntype == mujoco.mjtDyn.mjDYN_NONE
+    and actuator.biasprm[1] == 0
+    and actuator.gainprm[0] == -actuator.biasprm[2]
+  )
+
+
+def is_motor_actuator(actuator: mujoco.MjsActuator) -> bool:
+  """Check if an actuator is a motor actuator.
+
+  Matches actuators created by ``MjsActuator.set_to_motor()`` or
+  ``create_motor_actuator()``.
+  """
+  return (
+    actuator.gaintype == mujoco.mjtGain.mjGAIN_FIXED
+    and actuator.biastype == mujoco.mjtBias.mjBIAS_NONE
+  )
+
+
+def is_muscle_actuator(actuator: mujoco.MjsActuator) -> bool:
+  """Check if an actuator is a muscle actuator."""
+  return actuator.dyntype == mujoco.mjtDyn.mjDYN_MUSCLE
+
+
+_ACTUATOR_PREDICATES: list[
+  tuple[Literal["position", "velocity", "effort"], Callable[[mujoco.MjsActuator], bool]]
+] = [
+  ("effort", is_muscle_actuator),
+  ("position", is_position_actuator),
+  ("velocity", is_velocity_actuator),
+  ("effort", is_motor_actuator),  # Broad; checked last.
+]
+
+
+def detect_command_field(
+  actuator: mujoco.MjsActuator,
+) -> Literal["position", "velocity", "effort"]:
+  """Detect which ``ActuatorCmd`` field an XML actuator expects as ctrl input.
+
+  Uses strict predicates that match the invariants set by MuJoCo's
+  ``mjs_setToPosition``, ``mjs_setToVelocity``, ``mjs_setToMotor``,
+  and ``mjs_setToMuscle``. Raises ``ValueError`` for unrecognized types.
+  """
+  for field, predicate in _ACTUATOR_PREDICATES:
+    if predicate(actuator):
+      return field
+  raise ValueError(
+    f"Cannot determine command field for XML actuator '{actuator.name}'. "
+    f"Only position, velocity, motor, and muscle actuators are supported. "
+    f"For general actuators, use a custom actuator class."
+  )
+
+
+def dof_width(joint_type: int | mujoco.mjtJoint) -> int:
+  """Get the dimensionality of the joint in qvel."""
+  if isinstance(joint_type, mujoco.mjtJoint):
+    joint_type = joint_type.value
+  return {0: 6, 1: 3, 2: 1, 3: 1}[joint_type]
+
+
+def qpos_width(joint_type: int | mujoco.mjtJoint) -> int:
+  """Get the dimensionality of the joint in qpos."""
+  if isinstance(joint_type, mujoco.mjtJoint):
+    joint_type = joint_type.value
+  return {0: 7, 1: 4, 2: 1, 3: 1}[joint_type]
diff --git a/src/mjlab/utils/nan_guard.py b/src/mjlab/utils/nan_guard.py
new file mode 100644
index 0000000..b8ff04a
--- /dev/null
+++ b/src/mjlab/utils/nan_guard.py
@@ -0,0 +1,201 @@
+"""Lightweight NaN guard for capturing simulation states when NaN/Inf detected."""
+
+from collections import deque
+from contextlib import contextmanager
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Iterator
+
+import mujoco
+import mujoco_warp as mjwarp
+import numpy as np
+import torch
+
+
+@dataclass
+class NanGuardCfg:
+  """Configuration for NaN guard."""
+
+  enabled: bool = False
+  buffer_size: int = 100
+  output_dir: str = "/tmp/mjlab/nan_dumps"
+  max_envs_to_dump: int = 5
+
+
+class NanGuard:
+  """Guards against NaN/Inf by buffering states and dumping on detection.
+
+  When enabled, maintains a rolling buffer of simulation states and writes
+  them to disk when NaN or Inf is detected. When disabled, all operations
+  are no-ops with minimal overhead.
+  """
+
+  def __init__(self, cfg: NanGuardCfg, num_envs: int, mj_model: mujoco.MjModel) -> None:
+    self.enabled = cfg.enabled
+    self.num_envs = num_envs
+
+    if not self.enabled:
+      return
+
+    self.buffer_size = cfg.buffer_size
+    self.output_dir = Path(cfg.output_dir)
+    self.max_envs_to_dump = cfg.max_envs_to_dump
+    self.buffer: deque = deque(maxlen=self.buffer_size)
+    self.step_counter = 0
+    self._dumped = False
+
+    self.state_spec = mujoco.mjtState.mjSTATE_PHYSICS.value
+    if mj_model.nmocap > 0:
+      self.state_spec |= (
+        mujoco.mjtState.mjSTATE_MOCAP_POS.value
+        | mujoco.mjtState.mjSTATE_MOCAP_QUAT.value
+      )
+    self.state_size = mujoco.mj_stateSize(mj_model, self.state_spec)
+    self.mj_model = mj_model
+    self.mj_data = mujoco.MjData(mj_model)
+
+  def capture(self, wp_data: mjwarp.Data) -> None:
+    """Capture current simulation state to buffer."""
+    if not self.enabled:
+      return
+
+    state = {
+      "step": self.step_counter,
+      "qpos": wp_data.qpos.clone(),
+      "qvel": wp_data.qvel.clone(),
+    }
+    if self.mj_model.na > 0:
+      state["act"] = wp_data.act.clone()
+    if self.mj_model.nmocap > 0:
+      state["mocap_pos"] = wp_data.mocap_pos.clone()
+      state["mocap_quat"] = wp_data.mocap_quat.clone()
+
+    self.buffer.append(state)
+    self.step_counter += 1
+
+  @contextmanager
+  def watch(self, wp_data: mjwarp.Data) -> Iterator[None]:
+    """Context manager that captures state before and checks for NaN/Inf after.
+
+    Usage:
+      with nan_guard.watch(wp_data):
+        mjwarp.step(wp_model, wp_data)
+    """
+    self.capture(wp_data)
+    yield
+    self.check_and_dump(wp_data)
+
+  @staticmethod
+  def detect_nans(data: mjwarp.Data) -> torch.Tensor:
+    """Detect NaN/Inf values in physics state (qpos, qvel, qacc, qacc_warmstart).
+
+    Args:
+      data: MuJoCo simulation data containing physics state.
+
+    Returns:
+      Boolean tensor where True indicates environments with NaN/Inf values.
+    """
+    tensors_to_check = [
+      data.qpos,
+      data.qvel,
+      data.qacc,
+      data.qacc_warmstart,
+      data.sensordata,
+    ]
+
+    # Build per-env NaN mask (True if env has NaN/Inf in any tensor).
+    nan_mask = torch.zeros(
+      data.qpos.shape[0], dtype=torch.bool, device=data.qpos.device
+    )
+    for t in tensors_to_check:
+      nan_mask |= torch.isnan(t).any(dim=-1) | torch.isinf(t).any(dim=-1)
+
+    return nan_mask
+
+  def check_and_dump(self, data: mjwarp.Data) -> bool:
+    """Check for NaN/Inf and dump buffer if detected.
+
+    Returns:
+      True if NaN/Inf detected and dump occurred, False otherwise.
+    """
+    if not self.enabled or self._dumped:
+      return False
+
+    nan_mask = self.detect_nans(data)
+
+    if nan_mask.any():
+      nan_env_ids = torch.where(nan_mask)[0].cpu().numpy().tolist()
+      self._dump_buffer(nan_env_ids)
+      self._dumped = True
+      return True
+
+    return False
+
+  def _dump_buffer(self, nan_env_ids: list[int]) -> None:
+    """Write buffered states to disk."""
+    self.output_dir.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = self.output_dir / f"nan_dump_{timestamp}.npz"
+    model_filename = self.output_dir / f"model_{timestamp}.mjb"
+
+    envs_to_dump = nan_env_ids[: self.max_envs_to_dump]
+    data = {}
+    for item in self.buffer:
+      step = item["step"]
+      qpos = item["qpos"]
+      qvel = item["qvel"]
+      act = item.get("act", None)
+      mocap_pos = item.get("mocap_pos", None)
+      mocap_quat = item.get("mocap_quat", None)
+
+      states = np.empty((len(envs_to_dump), self.state_size))
+      for idx, env_id in enumerate(envs_to_dump):
+        self.mj_data.qpos[:] = qpos[env_id].cpu().numpy()
+        self.mj_data.qvel[:] = qvel[env_id].cpu().numpy()
+        if act is not None:
+          self.mj_data.act[:] = act[env_id].cpu().numpy()
+        if mocap_pos is not None:
+          self.mj_data.mocap_pos[:] = mocap_pos[env_id].cpu().numpy()
+          self.mj_data.mocap_quat[:] = mocap_quat[env_id].cpu().numpy()
+
+        mujoco.mj_getState(self.mj_model, self.mj_data, states[idx], self.state_spec)
+
+      data[f"states_step_{step:06d}"] = states
+
+    data["_metadata"] = np.array(
+      {
+        "num_envs_total": self.num_envs,
+        "num_envs_dumped": len(envs_to_dump),
+        "nan_env_ids": nan_env_ids,
+        "dumped_env_ids": list(envs_to_dump),
+        "state_spec": self.state_spec,
+        "state_size": self.state_size,
+        "buffer_size": len(self.buffer),
+        "detection_step": self.step_counter,
+        "timestamp": timestamp,
+        "model_file": model_filename.name,
+        "note": "States captured using mj_getState with state_spec. "
+        "Use mj_setState with the same spec to restore. "
+        "Model saved as MJB for easy reloading.",
+      },
+      dtype=object,
+    )
+
+    np.savez_compressed(filename, **data)
+    mujoco.mj_saveModel(self.mj_model, str(model_filename), None)
+
+    # Create symlinks to latest dumps
+    latest_dump = self.output_dir / "nan_dump_latest.npz"
+    latest_model = self.output_dir / "model_latest.mjb"
+    latest_dump.unlink(missing_ok=True)
+    latest_model.unlink(missing_ok=True)
+    latest_dump.symlink_to(filename.name)
+    latest_model.symlink_to(model_filename.name)
+
+    print(f"[NanGuard] Detected NaN/Inf at step {self.step_counter}")
+    print(f"[NanGuard] NaN/Inf found in envs: {nan_env_ids[:10]}...")
+    print(f"[NanGuard] Dumping {len(envs_to_dump)} envs: {envs_to_dump}")
+    print(f"[NanGuard] Dumped {len(self.buffer)} states to: {filename}")
+    print(f"[NanGuard] Saved model to: {model_filename}")
+    print(f"[NanGuard] Latest dump symlinked at: {latest_dump}")
diff --git a/src/mjlab/utils/noise/__init__.py b/src/mjlab/utils/noise/__init__.py
new file mode 100644
index 0000000..56840be
--- /dev/null
+++ b/src/mjlab/utils/noise/__init__.py
@@ -0,0 +1,12 @@
+from mjlab.utils.noise.noise_cfg import ConstantNoiseCfg as ConstantNoiseCfg
+from mjlab.utils.noise.noise_cfg import GaussianNoiseCfg as GaussianNoiseCfg
+from mjlab.utils.noise.noise_cfg import NoiseCfg as NoiseCfg
+from mjlab.utils.noise.noise_cfg import NoiseModelCfg as NoiseModelCfg
+from mjlab.utils.noise.noise_cfg import (
+  NoiseModelWithAdditiveBiasCfg as NoiseModelWithAdditiveBiasCfg,
+)
+from mjlab.utils.noise.noise_cfg import UniformNoiseCfg as UniformNoiseCfg
+from mjlab.utils.noise.noise_model import NoiseModel as NoiseModel
+from mjlab.utils.noise.noise_model import (
+  NoiseModelWithAdditiveBias as NoiseModelWithAdditiveBias,
+)
diff --git a/src/mjlab/utils/noise/noise_cfg.py b/src/mjlab/utils/noise/noise_cfg.py
new file mode 100644
index 0000000..7abd30e
--- /dev/null
+++ b/src/mjlab/utils/noise/noise_cfg.py
@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import abc
+from dataclasses import dataclass, field
+from typing import ClassVar, Literal
+
+import torch
+from typing_extensions import override
+
+from mjlab.utils.noise import noise_model
+
+# Type alias for noise parameters: scalar or per-dimension values.
+NoiseParam = float | tuple[float, ...]
+
+
+@dataclass(kw_only=True)
+class NoiseCfg(abc.ABC):
+  """Base configuration for a noise term."""
+
+  operation: Literal["add", "scale", "abs"] = "add"
+
+  # Cache for converted tensors, keyed by device string.
+  _tensor_cache: dict[str, dict[str, torch.Tensor]] = field(
+    default_factory=dict, init=False, repr=False
+  )
+
+  def _get_cached_tensor(
+    self, name: str, value: NoiseParam, device: torch.device
+  ) -> torch.Tensor:
+    """Get a cached tensor for the given parameter on the specified device."""
+    device_key = str(device)
+    if device_key not in self._tensor_cache:
+      self._tensor_cache[device_key] = {}
+    if name not in self._tensor_cache[device_key]:
+      self._tensor_cache[device_key][name] = torch.tensor(value, device=device)
+    return self._tensor_cache[device_key][name]
+
+  @abc.abstractmethod
+  def apply(self, data: torch.Tensor) -> torch.Tensor:
+    """Apply noise to the input data."""
+
+
+@dataclass
+class ConstantNoiseCfg(NoiseCfg):
+  bias: NoiseParam = 0.0
+
+  @override
+  def apply(self, data: torch.Tensor) -> torch.Tensor:
+    bias = self._get_cached_tensor("bias", self.bias, data.device)
+
+    if self.operation == "add":
+      return data + bias
+    elif self.operation == "scale":
+      return data * bias
+    elif self.operation == "abs":
+      return torch.zeros_like(data) + bias
+    else:
+      raise ValueError(f"Unsupported noise operation: {self.operation}")
+
+
+@dataclass
+class UniformNoiseCfg(NoiseCfg):
+  n_min: NoiseParam = -1.0
+  n_max: NoiseParam = 1.0
+
+  def __post_init__(self):
+    if isinstance(self.n_min, float) and isinstance(self.n_max, float):
+      if self.n_min >= self.n_max:
+        raise ValueError(f"n_min ({self.n_min}) must be less than n_max ({self.n_max})")
+
+  @override
+  def apply(self, data: torch.Tensor) -> torch.Tensor:
+    n_min = self._get_cached_tensor("n_min", self.n_min, data.device)
+    n_max = self._get_cached_tensor("n_max", self.n_max, data.device)
+
+    # Generate uniform noise in [0, 1) and scale to [n_min, n_max).
+    noise = torch.rand_like(data) * (n_max - n_min) + n_min
+
+    if self.operation == "add":
+      return data + noise
+    elif self.operation == "scale":
+      return data * noise
+    elif self.operation == "abs":
+      return noise
+    else:
+      raise ValueError(f"Unsupported noise operation: {self.operation}")
+
+
+@dataclass
+class GaussianNoiseCfg(NoiseCfg):
+  mean: NoiseParam = 0.0
+  std: NoiseParam = 1.0
+
+  def __post_init__(self):
+    if isinstance(self.std, float) and self.std <= 0:
+      raise ValueError(f"std ({self.std}) must be positive")
+
+  @override
+  def apply(self, data: torch.Tensor) -> torch.Tensor:
+    mean = self._get_cached_tensor("mean", self.mean, data.device)
+    std = self._get_cached_tensor("std", self.std, data.device)
+
+    # Generate standard normal noise and scale.
+    noise = mean + std * torch.randn_like(data)
+
+    if self.operation == "add":
+      return data + noise
+    elif self.operation == "scale":
+      return data * noise
+    elif self.operation == "abs":
+      return noise
+    else:
+      raise ValueError(f"Unsupported noise operation: {self.operation}")
+
+
+##
+# Noise models.
+##
+
+
+@dataclass(kw_only=True)
+class NoiseModelCfg:
+  """Configuration for a noise model."""
+
+  noise_cfg: NoiseCfg
+
+  class_type: ClassVar[type[noise_model.NoiseModel]] = noise_model.NoiseModel
+
+  def __init_subclass__(cls, class_type: type[noise_model.NoiseModel]):
+    cls.class_type = class_type
+
+
+@dataclass(kw_only=True)
+class NoiseModelWithAdditiveBiasCfg(
+  NoiseModelCfg, class_type=noise_model.NoiseModelWithAdditiveBias
+):
+  """Configuration for an additive Gaussian noise with bias model."""
+
+  bias_noise_cfg: NoiseCfg | None = None
+  sample_bias_per_component: bool = True
+
+  def __post_init__(self):
+    if self.bias_noise_cfg is None:
+      raise ValueError(
+        "bias_noise_cfg must be specified for NoiseModelWithAdditiveBiasCfg"
+      )
diff --git a/src/mjlab/utils/noise/noise_model.py b/src/mjlab/utils/noise/noise_model.py
new file mode 100644
index 0000000..6e75db4
--- /dev/null
+++ b/src/mjlab/utils/noise/noise_model.py
@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+from typing_extensions import override
+
+if TYPE_CHECKING:
+  from mjlab.utils.noise import noise_cfg
+
+
+class NoiseModel:
+  """Base class for noise models."""
+
+  def __init__(
+    self, noise_model_cfg: noise_cfg.NoiseModelCfg, num_envs: int, device: str
+  ):
+    self._noise_model_cfg = noise_model_cfg
+    self._num_envs = num_envs
+    self._device = device
+
+    # Validate configuration.
+    if not hasattr(noise_model_cfg, "noise_cfg") or noise_model_cfg.noise_cfg is None:
+      raise ValueError("NoiseModelCfg must have a valid noise_cfg")
+
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    """Reset noise model state. Override in subclasses if needed."""
+
+  def __call__(self, data: torch.Tensor) -> torch.Tensor:
+    """Apply noise to input data."""
+    assert self._noise_model_cfg.noise_cfg is not None
+    return self._noise_model_cfg.noise_cfg.apply(data)
+
+
+class NoiseModelWithAdditiveBias(NoiseModel):
+  """Noise model with additional additive bias that is constant for the duration
+  of the entire episode."""
+
+  def __init__(
+    self,
+    noise_model_cfg: noise_cfg.NoiseModelWithAdditiveBiasCfg,
+    num_envs: int,
+    device: str,
+  ):
+    super().__init__(noise_model_cfg, num_envs, device)
+
+    # Validate bias configuration.
+    if (
+      not hasattr(noise_model_cfg, "bias_noise_cfg")
+      or noise_model_cfg.bias_noise_cfg is None
+    ):
+      raise ValueError("NoiseModelWithAdditiveBiasCfg must have a valid bias_noise_cfg")
+
+    self._bias_noise_cfg = noise_model_cfg.bias_noise_cfg
+    self._sample_bias_per_component = noise_model_cfg.sample_bias_per_component
+
+    # Initialize bias tensor.
+    self._bias = torch.zeros((num_envs, 1), device=self._device)
+    self._num_components: int | None = None
+    self._bias_initialized = False
+
+  @override
+  def reset(self, env_ids: torch.Tensor | slice | None = None) -> None:
+    """Reset bias values for specified environments."""
+    indices = slice(None) if env_ids is None else env_ids
+    # Sample new bias values.
+    self._bias[indices] = self._bias_noise_cfg.apply(self._bias[indices])
+
+  def _initialize_bias_shape(self, data_shape: torch.Size) -> None:
+    """Initialize bias tensor shape based on data and configuration."""
+    if self._sample_bias_per_component and not self._bias_initialized:
+      *_, self._num_components = data_shape
+      # Expand bias to match number of components.
+      self._bias = self._bias.repeat(1, self._num_components)
+      self._bias_initialized = True
+      # Resample bias with new shape.
+      self.reset()
+
+  @override
+  def __call__(self, data: torch.Tensor) -> torch.Tensor:
+    """Apply noise and additive bias to input data."""
+    self._initialize_bias_shape(data.shape)
+    noisy_data = super().__call__(data)
+    return noisy_data + self._bias
diff --git a/src/mjlab/utils/os.py b/src/mjlab/utils/os.py
new file mode 100644
index 0000000..61b124c
--- /dev/null
+++ b/src/mjlab/utils/os.py
@@ -0,0 +1,104 @@
+import re
+from pathlib import Path
+from typing import Dict
+
+import yaml
+
+
+def dump_yaml(filename: Path, data: Dict, sort_keys: bool = False) -> None:
+  """Saves data to a YAML file.
+
+  Args:
+      filename: The path to the YAML file.
+      data: The data to save. Must be a dictionary.
+      sort_keys: Whether to sort the keys in the YAML file.
+  """
+  if not filename.suffix:
+    filename = filename.with_suffix(".yaml")
+  filename.parent.mkdir(parents=True, exist_ok=True)
+  with open(filename, "w") as f:
+    yaml.dump(data, f, sort_keys=sort_keys)
+
+
+def get_checkpoint_path(
+  log_path: Path,
+  run_dir: str = ".*",
+  checkpoint: str = ".*",
+  sort_alpha: bool = True,
+) -> Path:
+  """Get path to model checkpoint in input directory.
+
+  The checkpoint file is resolved as: `<log_path>/<run_dir>/<checkpoint>`.
+
+  If `run_dir` and `checkpoint` are regex expressions, then the most recent
+  (highest alphabetical order) run and checkpoint are selected. To disable this
+  behavior, set `sort_alpha` to `False`.
+  """
+  if not log_path.exists():
+    raise ValueError(f"Log path does not exist: {log_path}")
+  # Exclude wandb_checkpoints directory which is used for caching downloaded checkpoints.
+  runs = [
+    log_path / run.name
+    for run in log_path.iterdir()
+    if run.is_dir() and run.name != "wandb_checkpoints" and re.match(run_dir, run.name)
+  ]
+  if len(runs) == 0:
+    raise ValueError(f"No run directories found in {log_path} matching '{run_dir}'")
+  if sort_alpha:
+    runs.sort()
+  else:
+    runs = sorted(runs, key=lambda p: p.stat().st_mtime)
+  run_path = runs[-1]
+
+  model_checkpoints = [
+    f.name for f in run_path.iterdir() if re.match(checkpoint, f.name)
+  ]
+  if len(model_checkpoints) == 0:
+    raise ValueError(f"No checkpoint found in {run_path} matching {checkpoint}")
+  model_checkpoints.sort(key=lambda m: f"{m:0>15}")
+  checkpoint_file = model_checkpoints[-1]
+  return run_path / checkpoint_file
+
+
+def get_wandb_checkpoint_path(
+  log_path: Path, run_path: Path, checkpoint_name: str | None = None
+) -> tuple[Path, bool]:
+  """Get checkpoint path from wandb, downloading if needed.
+
+  Returns:
+    Tuple of (checkpoint_path, was_cached)
+  """
+  import wandb
+
+  # Extract run_id from path (e.g., "entity/project/run_id" -> "run_id").
+  run_id = str(run_path).split("/")[-1]
+  download_dir = log_path / "wandb_checkpoints" / run_id
+
+  # Query wandb API to find the latest checkpoint.
+  api = wandb.Api()
+  wandb_run = api.run(str(run_path))
+  files = [
+    file.name
+    for file in wandb_run.files(pattern="model_%.pt")
+    if re.match(r"^model_\d+\.pt$", file.name)
+  ]
+  if checkpoint_name is None:
+    checkpoint_file = max(files, key=lambda x: int(x.split("_")[1].split(".")[0]))
+  else:
+    if checkpoint_name not in files:
+      raise ValueError(
+        f"Checkpoint '{checkpoint_name}' not found in run {run_path}."
+        f" Available: {files}"
+      )
+    checkpoint_file = checkpoint_name
+
+  checkpoint_path = download_dir / checkpoint_file
+
+  # If this checkpoint is not cached locally, download it.
+  was_cached = checkpoint_path.exists()
+  if not was_cached:
+    download_dir.mkdir(parents=True, exist_ok=True)
+    wandb_file = wandb_run.file(str(checkpoint_file))
+    wandb_file.download(str(download_dir), replace=True)
+
+  return checkpoint_path, was_cached
diff --git a/src/mjlab/utils/random.py b/src/mjlab/utils/random.py
new file mode 100644
index 0000000..682a3a0
--- /dev/null
+++ b/src/mjlab/utils/random.py
@@ -0,0 +1,26 @@
+import os
+import random
+
+import numpy as np
+import torch
+import warp as wp
+
+
+def seed_rng(seed: int, torch_deterministic: bool = False) -> None:
+  """Seed all random number generators for reproducibility.
+
+  Note: MuJoCo Warp is not fully deterministic yet.
+  See: https://github.com/google-deepmind/mujoco_warp/issues/562
+  """
+  os.environ["PYTHONHASHSEED"] = str(seed)
+
+  random.seed(seed)
+  np.random.seed(seed)
+
+  wp.rand_init(wp.int32(seed))
+
+  # Ref: https://docs.pytorch.org/docs/stable/notes/randomness.html
+  torch.manual_seed(seed)  # Seed RNG for all devices.
+  # Use deterministic algorithms when possible.
+  if torch_deterministic:
+    torch.use_deterministic_algorithms(True, warn_only=True)
diff --git a/src/mjlab/utils/spaces.py b/src/mjlab/utils/spaces.py
new file mode 100644
index 0000000..0176801
--- /dev/null
+++ b/src/mjlab/utils/spaces.py
@@ -0,0 +1,86 @@
+"""Lightweight space definitions for environment observations and actions.
+
+This module provides minimal space representations to replace gymnasium.spaces,
+focusing only on what mjlab needs (shape and dtype information for batching).
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+from typing import Literal, overload
+
+from typing_extensions import assert_never
+
+
+@dataclass
+class Space:
+  """Base space class with shape and dtype information."""
+
+  shape: tuple[int, ...] = ()
+  dtype: Literal["float32", "int32", "int64", "uint8"] = "float32"
+
+
+@dataclass
+class Box(Space):
+  """Continuous space with optional bounds."""
+
+  low: float | tuple[float, ...] = -math.inf
+  high: float | tuple[float, ...] = math.inf
+
+
+@dataclass
+class Dict(Space):
+  """Dictionary space containing multiple named subspaces."""
+
+  spaces: dict[str, Space] = field(default_factory=dict)
+
+
+@overload
+def batch_space(space: Dict, batch_size: int) -> Dict: ...
+
+
+@overload
+def batch_space(space: Box, batch_size: int) -> Box: ...
+
+
+@overload
+def batch_space(space: Space, batch_size: int) -> Space: ...
+
+
+def batch_space(space: Space, batch_size: int) -> Space:
+  """Create a batched version of a space.
+
+  Prepends batch_size dimension to the space's shape.
+
+  Args:
+      space: The space to batch
+      batch_size: Number of parallel environments
+
+  Returns:
+      New space with batched shape
+  """
+  if isinstance(space, Dict):
+    # For Dict spaces, batch each subspace.
+    return Dict(
+      spaces={
+        key: batch_space(subspace, batch_size) for key, subspace in space.spaces.items()
+      },
+      shape=(batch_size,),
+      dtype=space.dtype,
+    )
+  elif isinstance(space, Box):
+    # For Box spaces, prepend batch dimension.
+    batched_shape = (batch_size,) + space.shape
+    return Box(
+      shape=batched_shape,
+      low=space.low,
+      high=space.high,
+      dtype=space.dtype,
+    )
+  elif isinstance(space, Space):
+    # For generic Space, prepend batch dimension.
+    batched_shape = (batch_size,) + space.shape
+    return Space(shape=batched_shape, dtype=space.dtype)
+  else:
+    assert_never(space)
diff --git a/src/mjlab/utils/spec.py b/src/mjlab/utils/spec.py
new file mode 100644
index 0000000..492d4ba
--- /dev/null
+++ b/src/mjlab/utils/spec.py
@@ -0,0 +1,533 @@
+"""MjSpec utils."""
+
+from __future__ import annotations
+
+import shutil
+import xml.etree.ElementTree as ET
+import zipfile
+from pathlib import Path
+from typing import Callable
+
+import mujoco
+import numpy as np
+
+from mjlab.actuator.actuator import TransmissionType
+from mjlab.utils.xml import fix_spec_xml, strip_buffer_textures
+
+_DEFAULT_SPEC_OPTION = mujoco.MjSpec().option
+
+_OPTION_FIELDS = (
+  "ccd_iterations",
+  "ccd_tolerance",
+  "cone",
+  "density",
+  "disableactuator",
+  "disableflags",
+  "enableflags",
+  "gravity",
+  "impratio",
+  "integrator",
+  "iterations",
+  "jacobian",
+  "ls_iterations",
+  "ls_tolerance",
+  "magnetic",
+  "noslip_iterations",
+  "noslip_tolerance",
+  "o_friction",
+  "o_margin",
+  "o_solimp",
+  "o_solref",
+  "sdf_initpoints",
+  "sdf_iterations",
+  "sleep_tolerance",
+  "solver",
+  "timestep",
+  "tolerance",
+  "viscosity",
+  "wind",
+)
+
+
+def non_default_option_fields(opt: mujoco._specs.MjOption) -> list[str]:
+  """Return option field names that differ from MjSpec defaults."""
+  diffs = []
+  for name in _OPTION_FIELDS:
+    default = getattr(_DEFAULT_SPEC_OPTION, name)
+    value = getattr(opt, name)
+    if isinstance(default, np.ndarray):
+      if not np.array_equal(default, value):
+        diffs.append(name)
+    elif default != value:
+      diffs.append(name)
+  return diffs
+
+
+def export_spec(
+  spec: mujoco.MjSpec,
+  output_dir: Path,
+  *,
+  zip: bool = False,
+) -> None:
+  """Write a spec's XML and referenced mesh assets to a directory.
+
+  Creates ``scene.xml`` and an ``assets/`` subdirectory containing only the assets
+  referenced by the generated XML. When *zip* is True the directory is compressed into
+  a ``.zip`` archive and removed.
+
+  Operates on a copy of spec to avoid mutation.
+  """
+  output_dir.mkdir(parents=True, exist_ok=True)
+  tmp = spec.copy()
+  strip_buffer_textures(tmp)
+  xml = fix_spec_xml(tmp.to_xml(), meshdir="assets")
+  (output_dir / "scene.xml").write_text(xml)
+
+  # Collect file paths referenced in the XML.
+  root = ET.fromstring(xml)
+  referenced: set[str] = set()
+  for elem in root.iter():
+    file_val = elem.get("file")
+    if file_val:
+      referenced.add(file_val)
+
+  # Write only referenced assets. Match asset keys to XML file attributes by path
+  # suffix because keys may carry the original meshdir prefix (e.g.
+  # "../../meshes/robot/arm.stl" for a file attribute of "robot/arm.stl").
+  assets_dir = output_dir / "assets"
+  for ref_path in sorted(referenced):
+    for key, data in tmp.assets.items():
+      norm = key.replace("\\", "/")
+      if norm == ref_path or norm.endswith("/" + ref_path):
+        out = assets_dir / ref_path
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_bytes(data)
+        break
+
+  if zip:
+    zip_path = output_dir.with_suffix(".zip")
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+      for file in sorted(output_dir.rglob("*")):
+        if file.is_file():
+          zf.write(file, file.relative_to(output_dir))
+    shutil.rmtree(output_dir)
+
+
+_TRANSMISSION_TYPE_MAP = {
+  TransmissionType.JOINT: mujoco.mjtTrn.mjTRN_JOINT,
+  TransmissionType.TENDON: mujoco.mjtTrn.mjTRN_TENDON,
+  TransmissionType.SITE: mujoco.mjtTrn.mjTRN_SITE,
+}
+
+
+def apply_target_overrides(
+  spec: mujoco.MjSpec,
+  target_name: str,
+  transmission_type: TransmissionType,
+  *,
+  armature: float | None,
+  frictionloss: float | None,
+  viscous_damping: float | None,
+) -> None:
+  """Apply joint- or tendon-level overrides. ``None`` preserves the XML value.
+
+  SITE transmission is a no-op (sites have no armature / frictionloss / damping);
+  callers using SITE should not pass non-None overrides.
+  """
+  if transmission_type == TransmissionType.JOINT:
+    target = spec.joint(target_name)
+  elif transmission_type == TransmissionType.TENDON:
+    target = spec.tendon(target_name)
+  else:
+    return
+  if armature is not None:
+    target.armature = armature
+  if frictionloss is not None:
+    target.frictionloss = frictionloss
+  if viscous_damping is not None:
+    target.damping[0] = viscous_damping
+
+
+def auto_wrap_fixed_base_mocap(
+  spec_fn: Callable[[], mujoco.MjSpec],
+) -> Callable[[], mujoco.MjSpec]:
+  """Wraps spec_fn to auto-wrap fixed-base entities in mocap.
+
+  This enables fixed-base entities to be positioned independently per environment.
+  Returns original spec unchanged if entity is floating-base or already mocap.
+
+  .. note::
+    Mocap wrapping is automatic, but positioning only happens when you call a
+    reset event (e.g., reset_root_state_uniform). Without a reset event, all
+    fixed-base robots will remain at the world origin.
+
+  See FAQ: "Why are my fixed-base robots all stacked at the origin?"
+  """
+
+  def wrapper() -> mujoco.MjSpec:
+    original_spec = spec_fn()
+
+    # Check if entity has freejoint (floating-base).
+    free_joint = get_free_joint(original_spec)
+    if free_joint is not None:
+      return original_spec  # Floating-base, no wrapping needed.
+
+    # Check if root body is already mocap.
+    root_body = original_spec.bodies[1] if len(original_spec.bodies) > 1 else None
+    if root_body and root_body.mocap:
+      return original_spec  # Already mocap, no wrapping needed.
+
+    # Extract and delete keyframes before attach (they transfer but we need
+    # them on the wrapper spec, not nested in the attached spec).
+    keyframes = [
+      (np.array(k.qpos), np.array(k.ctrl), k.name) for k in original_spec.keys
+    ]
+    for k in list(original_spec.keys):
+      original_spec.delete(k)
+
+    # Wrap in mocap body.
+    wrapper_spec = mujoco.MjSpec()
+    mocap_body = wrapper_spec.worldbody.add_body(name="mocap_base", mocap=True)
+    frame = mocap_body.add_frame()
+    wrapper_spec.attach(child=original_spec, prefix="", frame=frame)
+
+    # Re-add keyframes to wrapper spec.
+    for qpos, ctrl, name in keyframes:
+      wrapper_spec.add_key(name=name, qpos=qpos.tolist(), ctrl=ctrl.tolist())
+
+    return wrapper_spec
+
+  return wrapper
+
+
+def get_non_free_joints(spec: mujoco.MjSpec) -> tuple[mujoco.MjsJoint, ...]:
+  """Returns all joints except the free joint."""
+  joints: list[mujoco.MjsJoint] = []
+  for jnt in spec.joints:
+    if jnt.type == mujoco.mjtJoint.mjJNT_FREE:
+      continue
+    joints.append(jnt)
+  return tuple(joints)
+
+
+def get_free_joint(spec: mujoco.MjSpec) -> mujoco.MjsJoint | None:
+  """Returns the free joint. None if no free joint exists."""
+  joint: mujoco.MjsJoint | None = None
+  for jnt in spec.joints:
+    if jnt.type == mujoco.mjtJoint.mjJNT_FREE:
+      joint = jnt
+      break
+  return joint
+
+
+def is_joint_limited(jnt: mujoco.MjsJoint) -> bool:
+  """Returns True if a joint is limited."""
+  match jnt.limited:
+    case mujoco.mjtLimited.mjLIMITED_TRUE:
+      return True
+    case mujoco.mjtLimited.mjLIMITED_AUTO:
+      return jnt.range[0] < jnt.range[1]
+    case _:
+      return False
+
+
+def create_motor_actuator(
+  spec: mujoco.MjSpec,
+  joint_name: str,
+  *,
+  effort_limit: float,
+  gear: float = 1.0,
+  armature: float | None = None,
+  frictionloss: float | None = None,
+  viscous_damping: float | None = None,
+  transmission_type: TransmissionType = TransmissionType.JOINT,
+) -> mujoco.MjsActuator:
+  """Create a <motor> actuator."""
+  actuator = spec.add_actuator(name=joint_name, target=joint_name)
+
+  actuator.trntype = _TRANSMISSION_TYPE_MAP[transmission_type]
+  actuator.dyntype = mujoco.mjtDyn.mjDYN_NONE
+  actuator.gaintype = mujoco.mjtGain.mjGAIN_FIXED
+  actuator.biastype = mujoco.mjtBias.mjBIAS_NONE
+
+  actuator.gear[0] = gear
+  # Technically redundant to set both but being explicit here.
+  actuator.forcelimited = True
+  actuator.forcerange[:] = np.array([-effort_limit, effort_limit])
+  actuator.ctrllimited = True
+  actuator.ctrlrange[:] = np.array([-effort_limit, effort_limit])
+
+  apply_target_overrides(
+    spec,
+    joint_name,
+    transmission_type,
+    armature=armature,
+    frictionloss=frictionloss,
+    viscous_damping=viscous_damping,
+  )
+
+  return actuator
+
+
+def create_position_actuator(
+  spec: mujoco.MjSpec,
+  joint_name: str,
+  *,
+  stiffness: float,
+  damping: float,
+  effort_limit: float | None = None,
+  armature: float | None = None,
+  frictionloss: float | None = None,
+  viscous_damping: float | None = None,
+  transmission_type: TransmissionType = TransmissionType.JOINT,
+  actuator_name: str | None = None,
+) -> mujoco.MjsActuator:
+  """Creates a <position> actuator.
+
+  An important note about this actuator is that we set `ctrllimited` to False. This is
+  because we want to allow the policy to output setpoints that are outside the kinematic
+  limits of the joint.
+
+  ``actuator_name`` defaults to ``joint_name``; pass a distinct value when multiple
+  actuators target the same joint (e.g. paired position+velocity elements).
+  """
+  actuator = spec.add_actuator(
+    name=actuator_name if actuator_name is not None else joint_name,
+    target=joint_name,
+  )
+
+  actuator.trntype = _TRANSMISSION_TYPE_MAP[transmission_type]
+  actuator.dyntype = mujoco.mjtDyn.mjDYN_NONE
+  actuator.gaintype = mujoco.mjtGain.mjGAIN_FIXED
+  actuator.biastype = mujoco.mjtBias.mjBIAS_AFFINE
+
+  # Set stiffness and damping.
+  actuator.gainprm[0] = stiffness
+  actuator.biasprm[1] = -stiffness
+  actuator.biasprm[2] = -damping
+
+  # Position actuators must allow setpoints beyond joint limits.
+  # Since force = stiffness * (ctrl - pos), clamping ctrl to the joint range would
+  # produce zero force when the joint is at its limit. Force is still bounded by
+  # forcerange below. Both lines are needed: ctrllimited=False is the primary guard,
+  # and inheritrange=0 prevents MuJoCo from resolving the default ctrllimited=AUTO back
+  # to True when a joint range exists.
+  actuator.inheritrange = 0.0
+  actuator.ctrllimited = False
+  if effort_limit is not None:
+    actuator.forcelimited = True
+    actuator.forcerange[:] = np.array([-effort_limit, effort_limit])
+
+    # Informational ctrlrange (not enforced since ctrllimited=False).
+    # Assuming zero velocity, force = stiffness * (ctrl - pos). Solving for the ctrl
+    # that saturates force at the worst-case position gives:
+    #   ctrl_max = joint_high + effort_limit / stiffness
+    #   ctrl_min = joint_low  - effort_limit / stiffness
+    # Beyond this range, force is always clamped regardless of position.
+    if transmission_type == TransmissionType.JOINT:
+      target_range = spec.joint(joint_name).range
+    elif transmission_type == TransmissionType.TENDON:
+      target_range = spec.tendon(joint_name).range
+    else:
+      target_range = (0.0, 0.0)
+    delta = effort_limit / stiffness
+    actuator.ctrlrange[:] = np.array([target_range[0] - delta, target_range[1] + delta])
+  else:
+    actuator.forcelimited = False
+    # No forcerange needed.
+
+  apply_target_overrides(
+    spec,
+    joint_name,
+    transmission_type,
+    armature=armature,
+    frictionloss=frictionloss,
+    viscous_damping=viscous_damping,
+  )
+
+  return actuator
+
+
+def create_velocity_actuator(
+  spec: mujoco.MjSpec,
+  joint_name: str,
+  *,
+  damping: float,
+  effort_limit: float | None = None,
+  armature: float | None = None,
+  frictionloss: float | None = None,
+  viscous_damping: float | None = None,
+  transmission_type: TransmissionType = TransmissionType.JOINT,
+  actuator_name: str | None = None,
+) -> mujoco.MjsActuator:
+  """Creates a <velocity> actuator.
+
+  Control inputs are not clamped so that velocity commands work for any joint,
+  including continuous joints that have no range defined. Force output is still
+  bounded when effort_limit is set.
+
+  ``actuator_name`` defaults to ``joint_name``; pass a distinct value when multiple
+  actuators target the same joint (e.g. paired position+velocity elements).
+  """
+  actuator = spec.add_actuator(
+    name=actuator_name if actuator_name is not None else joint_name,
+    target=joint_name,
+  )
+
+  actuator.trntype = _TRANSMISSION_TYPE_MAP[transmission_type]
+  actuator.dyntype = mujoco.mjtDyn.mjDYN_NONE
+  actuator.gaintype = mujoco.mjtGain.mjGAIN_FIXED
+  actuator.biastype = mujoco.mjtBias.mjBIAS_AFFINE
+
+  actuator.inheritrange = 0.0
+  actuator.ctrllimited = False
+  actuator.gainprm[0] = damping
+  actuator.biasprm[2] = -damping
+
+  if effort_limit is not None:
+    # Will this throw an error with autolimits=True?
+    actuator.forcelimited = True
+    actuator.forcerange[:] = np.array([-effort_limit, effort_limit])
+  else:
+    actuator.forcelimited = False
+
+  apply_target_overrides(
+    spec,
+    joint_name,
+    transmission_type,
+    armature=armature,
+    frictionloss=frictionloss,
+    viscous_damping=viscous_damping,
+  )
+
+  return actuator
+
+
+def create_muscle_actuator(
+  spec: mujoco.MjSpec,
+  target_name: str,
+  *,
+  length_range: tuple[float, float] = (0.0, 0.0),
+  gear: float = 1.0,
+  timeconst: tuple[float, float] = (0.01, 0.04),
+  tausmooth: float = 0.0,
+  range: tuple[float, float] = (0.75, 1.05),
+  force: float = -1.0,
+  scale: float = 200.0,
+  lmin: float = 0.5,
+  lmax: float = 1.6,
+  vmax: float = 1.5,
+  fpmax: float = 1.3,
+  fvmax: float = 1.2,
+  transmission_type: TransmissionType = TransmissionType.TENDON,
+) -> mujoco.MjsActuator:
+  """Create a MuJoCo <muscle> actuator with muscle dynamics.
+
+  Muscles use special activation dynamics and force-length-velocity curves.
+  They can actuate tendons or joints.
+  """
+  actuator = spec.add_actuator(name=target_name, target=target_name)
+
+  if transmission_type not in [TransmissionType.JOINT, TransmissionType.TENDON]:
+    raise ValueError("Muscle actuators only support JOINT and TENDON transmissions.")
+  actuator.trntype = _TRANSMISSION_TYPE_MAP[transmission_type]
+  actuator.dyntype = mujoco.mjtDyn.mjDYN_MUSCLE
+  actuator.gaintype = mujoco.mjtGain.mjGAIN_MUSCLE
+  actuator.biastype = mujoco.mjtBias.mjBIAS_MUSCLE
+
+  actuator.gear[0] = gear
+  actuator.dynprm[0:3] = np.array([*timeconst, tausmooth])
+  actuator.gainprm[0:9] = np.array(
+    [*range, force, scale, lmin, lmax, vmax, fpmax, fvmax]
+  )
+  actuator.biasprm[:] = actuator.gainprm[:]
+  actuator.lengthrange[0:2] = length_range
+
+  # TODO(kevin): Double check this.
+  actuator.ctrllimited = True
+  actuator.ctrlrange[:] = np.array([0.0, 1.0])
+
+  return actuator
+
+
+# ---------------------------------------------------------------------------
+# Mesh variant helpers
+# ---------------------------------------------------------------------------
+
+
+def copy_mesh_data(src: mujoco.MjsMesh, dst: mujoco.MjsMesh) -> None:
+  """Copy mesh geometry from *src* to *dst*.
+
+  Copies vertex/face data, file path, scale, reference frame, and smoothing settings.
+  The ``name`` field is NOT copied; set it on *dst* before calling.
+  """
+  assert dst.name, "dst.name must be set before copy_mesh_data."
+  if src.file:
+    dst.file = src.file
+  if len(src.uservert) > 0:
+    dst.uservert = src.uservert
+  if len(src.userface) > 0:
+    dst.userface = src.userface
+  if len(src.usernormal) > 0:
+    dst.usernormal = src.usernormal
+  if len(src.usertexcoord) > 0:
+    dst.usertexcoord = src.usertexcoord
+  if len(src.userfacenormal) > 0:
+    dst.userfacenormal = src.userfacenormal
+  if len(src.userfacetexcoord) > 0:
+    dst.userfacetexcoord = src.userfacetexcoord
+  dst.scale[:] = src.scale
+  dst.refpos[:] = src.refpos
+  dst.refquat[:] = src.refquat
+  dst.smoothnormal = src.smoothnormal
+
+
+def copy_texture_data(src: mujoco.MjsTexture, dst: mujoco.MjsTexture) -> None:
+  """Copy texture data from *src* to *dst*.
+
+  Copies the file path or builtin/data fields, format, dimensions, and color
+  settings. The ``name`` field is NOT copied; set it on *dst* before calling.
+  """
+  assert dst.name, "dst.name must be set before copy_texture_data."
+  dst.type = src.type
+  dst.colorspace = src.colorspace
+  dst.builtin = src.builtin
+  dst.mark = src.mark
+  dst.rgb1[:] = src.rgb1
+  dst.rgb2[:] = src.rgb2
+  dst.markrgb[:] = src.markrgb
+  dst.random = src.random
+  dst.gridsize[:] = src.gridsize
+  dst.gridlayout = src.gridlayout
+  dst.width = src.width
+  dst.height = src.height
+  dst.nchannel = src.nchannel
+  dst.hflip = src.hflip
+  dst.vflip = src.vflip
+  if src.file:
+    dst.file = src.file
+  if len(src.cubefiles) > 0:
+    dst.cubefiles = src.cubefiles
+  if len(src.data) > 0:
+    dst.data = src.data
+  if src.content_type:
+    dst.content_type = src.content_type
+
+
+def copy_material_data(src: mujoco.MjsMaterial, dst: mujoco.MjsMaterial) -> None:
+  """Copy material data from *src* to *dst*.
+
+  Copies appearance settings (rgba, specular, shininess, ...) and texture
+  bindings. The ``name`` field is NOT copied; set it on *dst* before calling.
+  """
+  assert dst.name, "dst.name must be set before copy_material_data."
+  dst.rgba[:] = src.rgba
+  dst.emission = src.emission
+  dst.specular = src.specular
+  dst.shininess = src.shininess
+  dst.reflectance = src.reflectance
+  dst.roughness = src.roughness
+  dst.metallic = src.metallic
+  dst.texuniform = src.texuniform
+  dst.texrepeat[:] = src.texrepeat
+  dst.textures = list(src.textures)
diff --git a/src/mjlab/utils/spec_config.py b/src/mjlab/utils/spec_config.py
new file mode 100644
index 0000000..ca2c0ab
--- /dev/null
+++ b/src/mjlab/utils/spec_config.py
@@ -0,0 +1,600 @@
+import warnings
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any, Literal, Sequence
+
+import mujoco
+
+from mjlab.utils.string import filter_exp, resolve_field
+
+_TYPE_MAP = {
+  "2d": mujoco.mjtTexture.mjTEXTURE_2D,
+  "cube": mujoco.mjtTexture.mjTEXTURE_CUBE,
+  "skybox": mujoco.mjtTexture.mjTEXTURE_SKYBOX,
+}
+_BUILTIN_MAP = {
+  "checker": mujoco.mjtBuiltin.mjBUILTIN_CHECKER,
+  "gradient": mujoco.mjtBuiltin.mjBUILTIN_GRADIENT,
+  "flat": mujoco.mjtBuiltin.mjBUILTIN_FLAT,
+  "none": mujoco.mjtBuiltin.mjBUILTIN_NONE,
+}
+_MARK_MAP = {
+  "edge": mujoco.mjtMark.mjMARK_EDGE,
+  "cross": mujoco.mjtMark.mjMARK_CROSS,
+  "random": mujoco.mjtMark.mjMARK_RANDOM,
+  "none": mujoco.mjtMark.mjMARK_NONE,
+}
+
+# Geom attributes that define the discrete contact structure: which pairs
+# collide and what contact type they produce. CollisionCfg always writes these.
+_GEOM_STRUCTURAL_FIELDS = ("contype", "conaffinity", "condim", "priority")
+# Continuous contact parameters; None inherits the compiled XML value.
+_GEOM_TUNING_FIELDS = ("friction", "solref", "solimp", "margin", "gap", "solmix")
+_GEOM_COLLISION_FIELDS = _GEOM_STRUCTURAL_FIELDS + _GEOM_TUNING_FIELDS
+# Fields written element-wise into a fixed-size MuJoCo array.
+_GEOM_ARRAY_FIELDS = ("friction", "solref", "solimp")
+
+_VALID_CONDIM = (1, 3, 4, 6)
+
+
+def _field_items(value) -> list[tuple[str | None, Any]]:
+  """Normalize a scalar-or-dict field to (pattern, value) pairs."""
+  if isinstance(value, dict):
+    return list(value.items())
+  return [(None, value)]
+
+
+def _validate_geom_attr(name: str, value) -> None:
+  """Validate a scalar-or-dict geom attribute. None values are skipped."""
+  for pattern, v in _field_items(value):
+    if v is None or name in _GEOM_ARRAY_FIELDS:
+      continue
+    where = f" for pattern '{pattern}'" if pattern is not None else ""
+    if name == "condim":
+      if v not in _VALID_CONDIM:
+        raise ValueError(f"condim must be one of {set(_VALID_CONDIM)}, got {v}{where}")
+    elif name == "group":
+      if not 0 <= v < mujoco.mjNGROUP:
+        raise ValueError(f"group must be in [0, {mujoco.mjNGROUP}), got {v}{where}")
+    elif name in ("contype", "conaffinity", "priority", "margin", "gap"):
+      if v < 0:
+        raise ValueError(f"{name} must be non-negative, got {v}{where}")
+    elif name == "solmix":
+      if not 0 <= v <= 1:
+        raise ValueError(f"solmix must be in [0, 1], got {v}{where}")
+
+
+def _set_geom_attr(geom: mujoco.MjsGeom, name: str, value) -> None:
+  """Write a single geom attribute; None is a no-op."""
+  if value is None:
+    return
+  if name in _GEOM_ARRAY_FIELDS:
+    field = getattr(geom, name)
+    for i, v in enumerate(value):
+      field[i] = v
+  else:
+    setattr(geom, name, value)
+
+
+def _matched_geoms(spec: mujoco.MjSpec, exprs: tuple[str, ...]) -> list[mujoco.MjsGeom]:
+  """Return geom objects whose names match any expression.
+
+  Filters the geom objects by name membership instead of looking names up via
+  ``spec.geom(name)``, so unnamed geoms (which all share the empty-string name)
+  are handled correctly. Geoms sharing a name are matched as a group.
+  """
+  all_geoms: list[mujoco.MjsGeom] = spec.geoms
+  matched = set(filter_exp(exprs, tuple(g.name for g in all_geoms)))
+  return [g for g in all_geoms if g.name in matched]
+
+
+_LIGHT_TYPE_MAP = {
+  "directional": mujoco.mjtLightType.mjLIGHT_DIRECTIONAL,
+  "spot": mujoco.mjtLightType.mjLIGHT_SPOT,
+}
+
+_CAM_LIGHT_MODE_MAP = {
+  "fixed": mujoco.mjtCamLight.mjCAMLIGHT_FIXED,
+  "track": mujoco.mjtCamLight.mjCAMLIGHT_TRACK,
+  "trackcom": mujoco.mjtCamLight.mjCAMLIGHT_TRACKCOM,
+  "targetbody": mujoco.mjtCamLight.mjCAMLIGHT_TARGETBODY,
+  "targetbodycom": mujoco.mjtCamLight.mjCAMLIGHT_TARGETBODYCOM,
+}
+
+
+@dataclass
+class SpecCfg(ABC):
+  """Base class for all MuJoCo spec configurations."""
+
+  @abstractmethod
+  def edit_spec(self, spec: mujoco.MjSpec) -> None:
+    raise NotImplementedError
+
+  def validate(self) -> None:  # noqa: B027
+    """Optional validation method to be overridden by subclasses."""
+    pass
+
+
+@dataclass
+class TextureCfg(SpecCfg):
+  """Configuration to add a texture to the MuJoCo spec."""
+
+  name: str
+  """Name of the texture."""
+  type: Literal["2d", "cube", "skybox"]
+  """Texture type ("2d", "cube", or "skybox")."""
+  builtin: Literal["checker", "gradient", "flat", "none"] = "none"
+  """Built-in texture pattern ("checker", "gradient", "flat", or "none")."""
+  rgb1: tuple[float, float, float] | None = None
+  """First RGB color tuple."""
+  rgb2: tuple[float, float, float] | None = None
+  """Second RGB color tuple."""
+  width: int | None = None
+  """Texture width in pixels."""
+  height: int | None = None
+  """Texture height in pixels."""
+  mark: Literal["edge", "cross", "random", "none"] = "none"
+  """Marking pattern ("edge", "cross", "random", or "none")."""
+  markrgb: tuple[float, float, float] = (0.0, 0.0, 0.0)
+  """RGB color for markings."""
+  random: float = 0.01
+  """Fraction of marked pixels when mark is "random"."""
+  file: str | None = None
+  """Path to an image file to load the texture from."""
+  cubefiles: tuple[str, ...] | None = None
+  """Paths to the six face images of a cube or skybox texture."""
+  gridsize: tuple[int, int] | None = None
+  """Rows and columns of the face grid in the file. Cube and skybox only."""
+  gridlayout: str | None = None
+  """Twelve-character face layout of the grid in the file. Cube and skybox only."""
+  nchannel: int = 3
+  """Number of channels in the texture."""
+  hflip: bool = False
+  """Whether to flip the loaded image horizontally."""
+  vflip: bool = False
+  """Whether to flip the loaded image vertically."""
+
+  def edit_spec(self, spec: mujoco.MjSpec) -> None:
+    self.validate()
+
+    spec.add_texture(
+      name=self.name,
+      type=_TYPE_MAP[self.type],
+      builtin=_BUILTIN_MAP[self.builtin],
+      mark=_MARK_MAP[self.mark],
+      rgb1=self.rgb1,
+      rgb2=self.rgb2,
+      markrgb=self.markrgb,
+      random=self.random,
+      width=self.width,
+      height=self.height,
+      nchannel=self.nchannel,
+      file=self.file,
+      cubefiles=self.cubefiles,
+      gridsize=self.gridsize,
+      gridlayout=self.gridlayout,
+      hflip=self.hflip,
+      vflip=self.vflip,
+    )
+
+  def validate(self) -> None:
+    if self.width is not None and self.width <= 0:
+      raise ValueError("Texture width must be positive.")
+    if self.height is not None and self.height <= 0:
+      raise ValueError("Texture height must be positive.")
+    if self.builtin == "none" and self.file is None and self.cubefiles is None:
+      raise ValueError("Texture must specify a builtin pattern, a file, or cubefiles.")
+    # A 1x1 grid compiles to a single image, but the Warp renderer samples skyboxes
+    # as six faces stacked vertically. Any larger grid compiles to those six faces.
+    # A builtin pattern takes precedence over the file and always fills six faces.
+    if (
+      self.type == "skybox"
+      and self.builtin == "none"
+      and self.file is not None
+      and (self.gridsize is None or tuple(self.gridsize) == (1, 1))
+    ):
+      raise ValueError(
+        "A skybox loaded from a single file must declare a gridsize larger than "
+        "1x1, or be specified via cubefiles."
+      )
+
+
+@dataclass
+class MaterialCfg(SpecCfg):
+  """Configuration to add a material to the MuJoCo spec.
+
+  Optionally assigns the material to geoms matching ``geom_names_expr``.
+  """
+
+  name: str
+  """Name of the material."""
+  rgba: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0)
+  """RGBA color of the material. Without a texture this is the direct
+  surface color; with a texture it multiplies the texture colors."""
+  texuniform: bool = False
+  """Whether texture coordinates are uniform."""
+  texrepeat: tuple[float, float] = (1.0, 1.0)
+  """Texture repeat pattern (width, height). Must be positive."""
+  reflectance: float = 0.0
+  """Material reflectance value."""
+  texture: str | None = None
+  """Name of texture to apply (optional)."""
+  geom_names_expr: tuple[str, ...] | None = None
+  """Regex patterns to match geom names. Matching geoms will have their
+  material set to this material. ``None`` means no assignment."""
+
+  def edit_spec(self, spec: mujoco.MjSpec) -> None:
+    self.validate()
+
+    mat = spec.add_material(
+      name=self.name,
+      rgba=self.rgba,
+      texuniform=self.texuniform,
+      texrepeat=self.texrepeat,
+      reflectance=self.reflectance,
+    )
+    if self.texture is not None:
+      mat.textures[mujoco.mjtTextureRole.mjTEXROLE_RGB.value] = self.texture
+
+    if self.geom_names_expr is not None:
+      all_geom_names = tuple(g.name for g in spec.geoms)
+      matched = filter_exp(self.geom_names_expr, all_geom_names)
+      for geom_name in matched:
+        spec.geom(geom_name).material = self.name
+
+  def validate(self) -> None:
+    if self.texrepeat[0] <= 0 or self.texrepeat[1] <= 0:
+      raise ValueError("Material texrepeat values must be positive.")
+
+
+@dataclass
+class MeshCfg(SpecCfg):
+  """Configuration to edit attributes of existing mesh assets in the MuJoCo spec.
+
+  Unlike geom attributes, which are edited per geom via GeomCfg and CollisionCfg,
+  the attributes here belong to the mesh asset itself. A mesh asset is a shared
+  resource: one asset may be referenced by many
+  mesh geoms across different bodies, and there is a single convex hull per asset.
+  Attributes are therefore matched by mesh-asset name, not geom name.
+
+  Only attributes set to a non-None value are applied; everything else is left at
+  whatever the source XML compiled to.
+  """
+
+  mesh_names_expr: tuple[str, ...]
+  """Regex patterns to match mesh-asset names."""
+  maxhullvert: int | dict[str, int] | None = None
+  """Maximum vertex count for each matched mesh's collision convex hull. Lower
+  values yield cheaper narrowphase collision (the support function walks fewer hull
+  vertices) at the cost of hull fidelity. -1 means unlimited (MuJoCo's default);
+  positive values must be greater than 3. May be a single value applied to all
+  matched meshes, or a dict mapping regex patterns to per-mesh values."""
+
+  def edit_spec(self, spec: mujoco.MjSpec) -> None:
+    self.validate()
+
+    all_mesh_names = tuple(m.name for m in spec.meshes)
+    matched = filter_exp(self.mesh_names_expr, all_mesh_names)
+
+    maxhullvert = resolve_field(self.maxhullvert, matched)
+    for i, mesh_name in enumerate(matched):
+      if maxhullvert[i] is not None:
+        spec.mesh(mesh_name).maxhullvert = maxhullvert[i]
+
+  def validate(self) -> None:
+    if isinstance(self.maxhullvert, dict):
+      items = list(self.maxhullvert.items())
+    else:
+      items = [(None, self.maxhullvert)]
+    for pattern, value in items:
+      if value is None or value == -1:
+        continue
+      if value <= 3:
+        where = f" for pattern '{pattern}'" if pattern is not None else ""
+        raise ValueError(
+          f"maxhullvert must be -1 (unlimited) or greater than 3, got {value}{where}"
+        )
+
+
+@dataclass
+class GeomCfg(SpecCfg):
+  """Sparse patch on attributes of existing geoms in the MuJoCo spec.
+
+  Geoms are matched by regex against their names; unnamed geoms match the empty
+  string. Every attribute defaults to None, and only attributes set to a
+  non-None value are applied; everything else is left at whatever the source
+  XML compiled to.
+
+  This is the single low-level editor for geom attributes. CollisionCfg is a
+  higher-level policy built on the same machinery that *replaces* an entity's
+  collision structure instead of patching it; prefer CollisionCfg for defining
+  which geoms collide, and GeomCfg for targeted tweaks. Within an EntityCfg,
+  CollisionCfg is applied after GeomCfg and overwrites any collision
+  attributes it also touches.
+
+  All attributes may be a single value applied to all matched geoms, or a dict
+  mapping regex patterns to per-geom values (first matching pattern wins;
+  geoms matching no pattern are left untouched).
+  """
+
+  geom_names_expr: tuple[str, ...]
+  """Regex patterns to match geom names."""
+  group: int | dict[str, int] | None = None
+  """Visualization group for each matched geom. Viewers and sensors draw groups
+  0-2 by default, so moving a geom to group 3-5 keeps it colliding while hiding
+  it from rendering. Must be in [0, mjNGROUP): MuJoCo does not range-check the
+  group, and out-of-range values are clamped into range by raycasting but
+  dropped by the warp renderer."""
+  contype: int | dict[str, int] | None = None
+  """Collision type bitmask. Must be non-negative."""
+  conaffinity: int | dict[str, int] | None = None
+  """Collision affinity bitmask. Must be non-negative."""
+  condim: int | dict[str, int] | None = None
+  """Contact dimension. Must be one of {1, 3, 4, 6}."""
+  priority: int | dict[str, int] | None = None
+  """Collision priority. Must be non-negative."""
+  friction: tuple[float, ...] | dict[str, tuple[float, ...]] | None = None
+  """Friction coefficients (sliding, torsional, rolling)."""
+  solref: tuple[float, ...] | dict[str, tuple[float, ...]] | None = None
+  """Solver reference parameters."""
+  solimp: tuple[float, ...] | dict[str, tuple[float, ...]] | None = None
+  """Solver impedance parameters."""
+  margin: float | dict[str, float] | None = None
+  """Detection margin. Contacts are generated when geom distance < margin."""
+  gap: float | dict[str, float] | None = None
+  """Gap for solver inclusion. Contact included when dist < margin - gap."""
+  solmix: float | dict[str, float] | None = None
+  """Mixing weight for blending solver parameters between geom pairs."""
+
+  _PATCH_FIELDS = ("group",) + _GEOM_COLLISION_FIELDS
+
+  def edit_spec(self, spec: mujoco.MjSpec) -> None:
+    self.validate()
+
+    geom_subset = _matched_geoms(spec, self.geom_names_expr)
+    subset_names = tuple(g.name for g in geom_subset)
+    for field_name in self._PATCH_FIELDS:
+      values = resolve_field(getattr(self, field_name), subset_names)
+      for geom, value in zip(geom_subset, values, strict=True):
+        _set_geom_attr(geom, field_name, value)
+
+  def validate(self) -> None:
+    for field_name in self._PATCH_FIELDS:
+      _validate_geom_attr(field_name, getattr(self, field_name))
+
+
+@dataclass
+class CollisionCfg(SpecCfg):
+  """Collision policy for the geoms in a MuJoCo spec.
+
+  Unlike GeomCfg, which patches only the attributes you set, this config
+  *replaces* the collision structure of every matched geom: ``contype``,
+  ``conaffinity``, ``condim``, and ``priority`` are required and always
+  written, so the contact behavior of matched geoms is fully determined by
+  this config regardless of what the source XML compiled to. When one of
+  these structural fields is a dict, its patterns must cover every matched
+  geom; add a catch-all ``".*"`` entry for the default case.
+
+  Continuous contact parameters (``friction``, ``solref``, ``solimp``,
+  ``margin``, ``gap``, ``solmix``) are optional patches: None inherits the
+  compiled XML value.
+
+  With ``disable_other_geoms=True`` (the default), every geom *not* matched
+  by ``geom_names_expr`` has its contype and conaffinity zeroed, so a single
+  CollisionCfg describes the entire collision story of the spec it edits.
+  """
+
+  geom_names_expr: tuple[str, ...]
+  """Tuple of regex patterns to match geom names."""
+  contype: int | dict[str, int]
+  """Collision type bitmask. Must be non-negative."""
+  conaffinity: int | dict[str, int]
+  """Collision affinity bitmask. Must be non-negative."""
+  condim: int | dict[str, int]
+  """Contact dimension. Must be one of {1, 3, 4, 6}."""
+  priority: int | dict[str, int]
+  """Collision priority. Must be non-negative."""
+  friction: tuple[float, ...] | dict[str, tuple[float, ...]] | None = None
+  """Friction coefficients as tuple or dict mapping patterns to tuples."""
+  solref: tuple[float, ...] | dict[str, tuple[float, ...]] | None = None
+  """Solver reference parameters as tuple or dict mapping patterns to tuples."""
+  solimp: tuple[float, ...] | dict[str, tuple[float, ...]] | None = None
+  """Solver impedance parameters as tuple or dict mapping patterns to tuples."""
+  margin: float | dict[str, float] | None = None
+  """Detection margin. Contacts are generated when geom distance < margin."""
+  gap: float | dict[str, float] | None = None
+  """Gap for solver inclusion. Contact included when dist < margin - gap."""
+  solmix: float | dict[str, float] | None = None
+  """Mixing weight for blending solver parameters between geom pairs."""
+  disable_other_geoms: bool = True
+  """Whether to disable collision for non-matching geoms."""
+
+  def validate(self) -> None:
+    for field_name in _GEOM_STRUCTURAL_FIELDS:
+      if getattr(self, field_name) is None:
+        raise ValueError(
+          f"{field_name} is required: CollisionCfg fully determines the "
+          "collision structure of matched geoms and cannot leave it to the "
+          "source XML. Use GeomCfg for sparse patches."
+        )
+    for field_name in _GEOM_COLLISION_FIELDS:
+      _validate_geom_attr(field_name, getattr(self, field_name))
+
+  def edit_spec(self, spec: mujoco.MjSpec) -> None:
+    self.validate()
+
+    all_geoms: list[mujoco.MjsGeom] = spec.geoms
+    matched = set(filter_exp(self.geom_names_expr, tuple(g.name for g in all_geoms)))
+    geom_subset = [g for g in all_geoms if g.name in matched]
+    subset_names = tuple(g.name for g in geom_subset)
+
+    for field_name in _GEOM_COLLISION_FIELDS:
+      values = resolve_field(getattr(self, field_name), subset_names)
+      structural = field_name in _GEOM_STRUCTURAL_FIELDS
+      for geom, value in zip(geom_subset, values, strict=True):
+        if structural and value is None:
+          raise ValueError(
+            f"{field_name} dict does not match geom '{geom.name}'. Structural "
+            "collision fields must cover every matched geom; add a catch-all "
+            "'.*' entry for the default case."
+          )
+        _set_geom_attr(geom, field_name, value)
+
+    if self.disable_other_geoms:
+      for geom in all_geoms:
+        if geom.name not in matched:
+          geom.contype = 0
+          geom.conaffinity = 0
+
+
+def warn_overlapping_geom_edits(
+  geom_cfgs: Sequence[GeomCfg],
+  collision_cfgs: Sequence[CollisionCfg],
+  spec: mujoco.MjSpec,
+) -> None:
+  """Warn when GeomCfg collision patches would be overwritten by a CollisionCfg.
+
+  Within an EntityCfg, collision configs are applied after geom configs, so any
+  collision attribute both of them write on the same geom ends up with the
+  CollisionCfg value. This lint makes that silent last-writer-wins visible.
+  """
+  if not geom_cfgs or not collision_cfgs:
+    return
+
+  all_names = tuple(g.name for g in spec.geoms)
+
+  # (geom name, field) pairs each CollisionCfg will write.
+  policy_writes: set[tuple[str, str]] = set()
+  for ccfg in collision_cfgs:
+    matched = set(filter_exp(ccfg.geom_names_expr, all_names))
+    subset = tuple(sorted(matched))
+    for field_name in _GEOM_COLLISION_FIELDS:
+      values = resolve_field(getattr(ccfg, field_name), subset)
+      structural = field_name in _GEOM_STRUCTURAL_FIELDS
+      for name, value in zip(subset, values, strict=True):
+        if structural or value is not None:
+          policy_writes.add((name, field_name))
+    if ccfg.disable_other_geoms:
+      for name in set(all_names) - matched:
+        policy_writes.add((name, "contype"))
+        policy_writes.add((name, "conaffinity"))
+
+  clobbered: set[str] = set()
+  for gcfg in geom_cfgs:
+    matched = set(filter_exp(gcfg.geom_names_expr, all_names))
+    subset = tuple(sorted(matched))
+    for field_name in _GEOM_COLLISION_FIELDS:
+      values = resolve_field(getattr(gcfg, field_name), subset)
+      for name, value in zip(subset, values, strict=True):
+        if value is not None and (name, field_name) in policy_writes:
+          clobbered.add(f"{name}.{field_name}")
+
+  if clobbered:
+    shown = ", ".join(sorted(clobbered)[:8])
+    more = f" (and {len(clobbered) - 8} more)" if len(clobbered) > 8 else ""
+    warnings.warn(
+      f"GeomCfg sets collision attributes that a CollisionCfg (applied "
+      f"after) overwrites: {shown}{more}. Set these through CollisionCfg "
+      "instead.",
+      stacklevel=3,
+    )
+
+
+@dataclass
+class LightCfg(SpecCfg):
+  """Configuration to add a light to the MuJoCo spec."""
+
+  name: str | None = None
+  """Name of the light (optional)."""
+  body: str = "world"
+  """Body to attach light to (default: "world")."""
+  mode: str = "fixed"
+  """Light mode ("fixed", "track", "trackcom", "targetbody", "targetbodycom")."""
+  target: str | None = None
+  """Target body for tracking modes (optional)."""
+  type: Literal["spot", "directional"] = "spot"
+  """Light type ("spot" or "directional")."""
+  castshadow: bool = True
+  """Whether light casts shadows."""
+  pos: tuple[float, float, float] = (0.0, 0.0, 0.0)
+  """Light position (x, y, z)."""
+  dir: tuple[float, float, float] = (0.0, 0.0, -1.0)
+  """Light direction vector (x, y, z)."""
+  cutoff: float = 45.0
+  """Spot light cutoff angle in degrees."""
+  exponent: float = 10.0
+  """Spot light exponent."""
+  diffuse: tuple[float, float, float] | None = None
+  """Diffuse RGB color. ``None`` keeps MuJoCo's default."""
+  specular: tuple[float, float, float] | None = None
+  """Specular RGB color. ``None`` keeps MuJoCo's default."""
+  ambient: tuple[float, float, float] | None = None
+  """Ambient RGB color. ``None`` keeps MuJoCo's default."""
+  active: bool = True
+  """Whether the light is on."""
+  attenuation: tuple[float, float, float] = (1.0, 0.0, 0.0)
+  """Constant, linear, and quadratic attenuation coefficients."""
+
+  def edit_spec(self, spec: mujoco.MjSpec) -> None:
+    self.validate()
+
+    if self.body == "world":
+      body = spec.worldbody
+    else:
+      body = spec.body(self.body)
+    light = body.add_light(
+      mode=_CAM_LIGHT_MODE_MAP[self.mode],
+      type=_LIGHT_TYPE_MAP[self.type],
+      castshadow=self.castshadow,
+      pos=self.pos,
+      dir=self.dir,
+      cutoff=self.cutoff,
+      exponent=self.exponent,
+      diffuse=self.diffuse,
+      specular=self.specular,
+      ambient=self.ambient,
+      active=self.active,
+      attenuation=self.attenuation,
+    )
+    if self.name is not None:
+      light.name = self.name
+    if self.target is not None:
+      light.targetbody = self.target
+
+
+@dataclass
+class CameraCfg(SpecCfg):
+  """Configuration to add a camera to the MuJoCo spec."""
+
+  name: str
+  """Name of the camera."""
+  body: str = "world"
+  """Body to attach camera to (default: "world")."""
+  mode: str = "fixed"
+  """Camera mode ("fixed", "track", "trackcom", "targetbody", "targetbodycom")."""
+  target: str | None = None
+  """Target body for tracking modes (optional)."""
+  fovy: float = 45.0
+  """Field of view in degrees."""
+  pos: tuple[float, float, float] = (0.0, 0.0, 0.0)
+  """Camera position (x, y, z)."""
+  quat: tuple[float, float, float, float] = (1.0, 0.0, 0.0, 0.0)
+  """Camera orientation quaternion (w, x, y, z)."""
+
+  def edit_spec(self, spec: mujoco.MjSpec) -> None:
+    self.validate()
+
+    if self.body == "world":
+      body = spec.worldbody
+    else:
+      body = spec.body(self.body)
+    camera = body.add_camera(
+      mode=_CAM_LIGHT_MODE_MAP[self.mode],
+      fovy=self.fovy,
+      pos=self.pos,
+      quat=self.quat,
+    )
+    if self.name is not None:
+      camera.name = self.name
+    if self.target is not None:
+      camera.targetbody = self.target
diff --git a/src/mjlab/utils/string.py b/src/mjlab/utils/string.py
new file mode 100644
index 0000000..e57d55c
--- /dev/null
+++ b/src/mjlab/utils/string.py
@@ -0,0 +1,38 @@
+import re
+from typing import Any
+
+
+def resolve_expr(
+  pattern_map: dict[str, Any],
+  names: tuple[str, ...],
+  default_val: Any = None,
+) -> tuple[Any, ...]:
+  """Resolve a field value (scalar or dict) to a tuple of values matched by patterns."""
+  patterns = [(re.compile(pat), val) for pat, val in pattern_map.items()]
+
+  result = []
+  for name in names:
+    for pat, val in patterns:
+      if pat.match(name):
+        result.append(val)
+        break
+    else:
+      result.append(default_val)
+  return tuple(result)
+
+
+def filter_exp(
+  exprs: list[str] | tuple[str, ...], names: tuple[str, ...]
+) -> tuple[str, ...]:
+  """Filter names based on regex patterns."""
+  patterns = [re.compile(expr) for expr in exprs]
+  return tuple(name for name in names if any(pat.match(name) for pat in patterns))
+
+
+def resolve_field(
+  field: Any, names: tuple[str, ...], default_val: Any = None
+) -> tuple[Any, ...]:
+  if isinstance(field, dict):
+    return resolve_expr(field, names, default_val)
+  else:
+    return tuple([field] * len(names))
diff --git a/src/mjlab/utils/torch.py b/src/mjlab/utils/torch.py
new file mode 100644
index 0000000..4275bf4
--- /dev/null
+++ b/src/mjlab/utils/torch.py
@@ -0,0 +1,41 @@
+import torch
+from packaging.version import parse
+
+
+def configure_torch_backends(allow_tf32: bool = True, deterministic: bool = False):
+  """Configure PyTorch CUDA and cuDNN backends for performance/reproducibility.
+
+  Args:
+    allow_tf32: If True, use TF32 precision for faster computation on Ampere+ GPUs. If
+      False, use standard IEEE FP32 precision.
+    deterministic: If True, use deterministic algorithms (slower but reproducible).
+      If False, allow cuDNN to benchmark and select fastest algorithms.
+
+  Note:
+    TF32 uses reduced precision (10-bit mantissa vs 23-bit for FP32) for internal
+    matrix multiplications providing a speedup with minimal impact on accuracy.
+
+    See https://pytorch.org/docs/stable/notes/cuda.html#tf32-on-ampere for details.
+  """
+  torch_version = parse(torch.__version__.split("+")[0])  # Handle e.g., "2.9.0+cu118".
+  if torch_version >= parse("2.9.0"):
+    _configure_29(allow_tf32)
+  else:
+    _configure_pre29(allow_tf32)
+
+  torch.backends.cudnn.benchmark = not deterministic  # Find fastest algorithms.
+  torch.backends.cudnn.deterministic = deterministic  # Ensure reproducibility.
+
+
+def _configure_29(allow_tf32: bool):
+  """Configure PyTorch CUDA and cuDNN backends for PyTorch 2.9+."""
+  # tf32 for performance, ieee for full FP32 accuracy.
+  precision = "tf32" if allow_tf32 else "ieee"
+  torch.backends.cuda.matmul.fp32_precision = precision
+  torch.backends.cudnn.fp32_precision = precision  # type: ignore
+
+
+def _configure_pre29(allow_tf32: bool):
+  """Configure PyTorch CUDA and cuDNN backends for PyTorch <2.9."""
+  torch.backends.cuda.matmul.allow_tf32 = allow_tf32
+  torch.backends.cudnn.allow_tf32 = allow_tf32
diff --git a/src/mjlab/utils/wandb.py b/src/mjlab/utils/wandb.py
new file mode 100644
index 0000000..1775520
--- /dev/null
+++ b/src/mjlab/utils/wandb.py
@@ -0,0 +1,34 @@
+"""WandB utilities."""
+
+from __future__ import annotations
+
+import os
+from typing import Sequence
+
+
+def add_wandb_tags(tags: Sequence[str]) -> None:
+  """Add tags to the current wandb run.
+
+  Note: This function stores tags in wandb.config._wandb_tags if the run is not yet
+  initialized, allowing them to be retrieved later. If the run is already initialized,
+  tags are added directly.
+  """
+  if not tags:
+    return
+
+  try:
+    import wandb
+
+    if wandb.run is not None:
+      existing_tags = list(wandb.run.tags) if wandb.run.tags else []
+      new_tags = list(set(existing_tags + list(tags)))
+      wandb.run.tags = new_tags
+    else:
+      # Store tags to be added when run is initialized.
+      # This is a workaround for lazy wandb initialization in rsl_rl 3.1.0.
+      current_tags = os.environ.get("WANDB_TAGS", "")
+      all_tags = set(current_tags.split(",") if current_tags else [])
+      all_tags.update(tags)
+      os.environ["WANDB_TAGS"] = ",".join(sorted(all_tags))
+  except ImportError:
+    pass
diff --git a/src/mjlab/utils/wrappers/__init__.py b/src/mjlab/utils/wrappers/__init__.py
new file mode 100644
index 0000000..2a15b28
--- /dev/null
+++ b/src/mjlab/utils/wrappers/__init__.py
@@ -0,0 +1,3 @@
+"""Environment wrappers for mjlab."""
+
+from mjlab.utils.wrappers.video_recorder import VideoRecorder as VideoRecorder
diff --git a/src/mjlab/utils/wrappers/video_recorder.py b/src/mjlab/utils/wrappers/video_recorder.py
new file mode 100644
index 0000000..3689c81
--- /dev/null
+++ b/src/mjlab/utils/wrappers/video_recorder.py
@@ -0,0 +1,203 @@
+"""Video recording wrapper for environments."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Callable, Literal
+
+import mediapy as media
+import numpy as np
+import torch
+from typing_extensions import assert_never
+
+from mjlab.envs import ManagerBasedRlEnv
+
+
+class VideoRecorder(ManagerBasedRlEnv):
+  """Wraps an environment to record video during interaction.
+
+  A minimal wrapper that records frames as the environment steps.
+  Delegates all attribute access and method calls to the wrapped environment.
+
+  For vectorized environments, only records the first environment (index 0) and
+  tracks its episode boundaries. This matches gymnasium's RecordVideo behavior.
+
+  Note: Unlike gymnasium's RecordVideo, this wrapper allows both episode_trigger
+  and step_trigger to be used simultaneously. If both are provided, recording will
+  start when either trigger fires. The filename will reflect which trigger started
+  the recording (e.g., "rl-video-step-1000.mp4" or "rl-video-episode-5.mp4").
+
+  Args:
+      env: The environment to wrap and record.
+      video_folder: Directory to save videos to.
+      episode_trigger: Callable that returns True if should record this episode.
+          Receives the actual episode count (increments when env[0] episodes end).
+      step_trigger: Callable that returns True if should record this step.
+          Receives the global step count.
+      video_length: Maximum frames per video. If None, records until env[0] episode ends.
+          If set, records exactly that many frames regardless of episode boundaries.
+      name_prefix: Prefix for video filenames.
+      disable_logger: Whether to disable logging.
+  """
+
+  def __init__(
+    self,
+    env: ManagerBasedRlEnv,
+    video_folder: str | Path,
+    episode_trigger: Callable[[int], bool] | None = None,
+    step_trigger: Callable[[int], bool] | None = None,
+    video_length: int | None = None,
+    name_prefix: str = "rl-video",
+    disable_logger: bool = False,
+  ):
+    # Don't call super().__init__() - we're wrapping an existing env.
+    self._wrapped_env = env
+    self.video_folder = Path(video_folder)
+    self.video_folder.mkdir(parents=True, exist_ok=True)
+
+    self.episode_trigger = episode_trigger
+    self.step_trigger = step_trigger
+    self.video_length = video_length
+    self.name_prefix = name_prefix
+    self.disable_logger = disable_logger
+
+    self.step_count: int = 0
+    self.episode_count: int = 0  # Tracks actual episodes
+    self.video_count: int = 0  # Tracks completed videos
+    self.is_recording: bool = False
+    self.current_video_frames: list[np.ndarray] = []
+    self.current_video_path: Path | None = None
+    self.trigger_type: Literal["step", "episode"] | None = None
+
+  def __getattr__(self, name: str) -> Any:
+    """Delegate attribute access to wrapped environment."""
+    return getattr(self._wrapped_env, name)
+
+  @property
+  def unwrapped(self) -> ManagerBasedRlEnv:
+    """Get the unwrapped environment."""
+    return self._wrapped_env.unwrapped
+
+  def reset(self, **kwargs: Any) -> Any:
+    """Reset the environment."""
+    return self._wrapped_env.reset(**kwargs)
+
+  def step(self, action: torch.Tensor) -> Any:
+    """Step the environment and optionally record video.
+
+    Args:
+        action: Action tensor.
+
+    Returns:
+        Tuple of (obs, reward, terminated, truncated, info) from env.step().
+    """
+    # Check if we should start recording.
+    step_triggered = self.step_trigger is not None and self.step_trigger(
+      self.step_count
+    )
+    episode_triggered = self.episode_trigger is not None and self.episode_trigger(
+      self.episode_count
+    )
+
+    if (step_triggered or episode_triggered) and not self.is_recording:
+      # Track which trigger started the recording for filename generation
+      if step_triggered:
+        self.trigger_type = "step"
+      else:
+        self.trigger_type = "episode"
+      self._start_recording()
+
+    # Step the environment.
+    obs, reward, terminated, truncated, info = self._wrapped_env.step(action)
+
+    # Track episode boundaries (only for the first environment, which we're recording)
+    # This matches gymnasium's behavior for vectorized environments.
+    if terminated[0] or truncated[0]:
+      self.episode_count += 1
+
+    # Record frame if recording.
+    if self.is_recording:
+      self._record_frame()
+
+      # Check if we should stop recording.
+      # If video_length is set, stop only when reaching that length.
+      # If video_length is None, stop when the first environment (being recorded) terminates.
+      if self.video_length is not None:
+        should_stop = len(self.current_video_frames) >= self.video_length
+      else:
+        should_stop = terminated[0] or truncated[0]
+
+      if should_stop:
+        self._finish_recording()
+
+    self.step_count += 1
+
+    return obs, reward, terminated, truncated, info
+
+  def render(self) -> np.ndarray | None:
+    """Render the environment."""
+    return self._wrapped_env.render()
+
+  def close(self) -> None:
+    """Close the environment and finalize any open videos."""
+    if self.is_recording:
+      self._finish_recording()
+    self._wrapped_env.close()
+
+  def _start_recording(self) -> None:
+    """Start recording a new video."""
+    self.is_recording = True
+    self.current_video_frames = []
+
+    # Generate video filename based on which trigger started recording.
+    assert self.trigger_type is not None, "trigger_type must be set before recording"
+
+    if self.trigger_type == "step":
+      video_filename = f"{self.name_prefix}-step-{self.step_count}.mp4"
+    elif self.trigger_type == "episode":
+      video_filename = f"{self.name_prefix}-episode-{self.episode_count}.mp4"
+    else:
+      assert_never(self.trigger_type)
+
+    self.current_video_path = self.video_folder / video_filename
+
+    if not self.disable_logger:
+      print(f"[INFO] Recording video to {self.current_video_path}")
+
+  def _record_frame(self) -> None:
+    """Record a frame from the environment.
+
+    For vectorized environments, only records env[0].
+    """
+    if self._wrapped_env.render_mode == "rgb_array":
+      frame = self._wrapped_env.render()
+      if frame is not None:
+        # For vectorized envs: frame shape is (num_envs, height, width, 3).
+        # Extract the first environment's frame.
+        rgb_frame = (
+          frame[0] if isinstance(frame, np.ndarray) and frame.ndim == 4 else frame
+        )
+        self.current_video_frames.append(rgb_frame)
+
+  def _finish_recording(self) -> None:
+    """Finish recording and save the video."""
+    if self.current_video_frames:
+      # Convert frames to uint8 format.
+      video_frames = []
+      for frame in self.current_video_frames:
+        frame = np.asarray(frame) if not isinstance(frame, np.ndarray) else frame
+        if frame.dtype != np.uint8:
+          frame = (np.clip(frame, 0, 1) * 255).astype(np.uint8)
+        video_frames.append(frame)
+
+      fps = self._wrapped_env.metadata.get("render_fps", 30)
+      media.write_video(str(self.current_video_path), video_frames, fps=fps)
+
+      if not self.disable_logger:
+        print(f"[INFO] Saved video to {self.current_video_path}")
+
+    self.is_recording = False
+    self.current_video_frames = []
+    self.current_video_path = None
+    self.video_count += 1
+    self.trigger_type = None  # Reset trigger type after recording
diff --git a/src/mjlab/utils/xml.py b/src/mjlab/utils/xml.py
new file mode 100644
index 0000000..3b6080d
--- /dev/null
+++ b/src/mjlab/utils/xml.py
@@ -0,0 +1,102 @@
+"""XML fixup utilities for MjSpec.to_xml() output."""
+
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+
+import mujoco
+
+
+def strip_buffer_textures(spec: mujoco.MjSpec) -> None:
+  """Remove buffer textures and their materials from a spec.
+
+  MuJoCo's ``to_xml()`` cannot serialize textures created from raw pixel data
+  (``texture.data = ...``). This function deletes those textures and the materials that
+  reference them, and clears the material reference on any geom that used one.
+  """
+  buffer_names: set[str] = set()
+  for tex in list(spec.textures):
+    if len(tex.data) > 0:
+      buffer_names.add(tex.name)
+      spec.delete(tex)
+  if not buffer_names:
+    return
+  mat_names: set[str] = set()
+  for mat in list(spec.materials):
+    tex_name = mat.textures[mujoco.mjtTextureRole.mjTEXROLE_RGB]
+    if tex_name in buffer_names:
+      mat_names.add(mat.name)
+      spec.delete(mat)
+  if not mat_names:
+    return
+  for geom in spec.geoms:
+    if geom.material in mat_names:
+      geom.material = ""
+
+
+def _collapse_defaults(elem: ET.Element) -> None:
+  """Collapse duplicate nested defaults with the same class name.
+
+  MjSpec.to_xml() emits ``<default class="X"><default class="X">...`` after
+  ``attach(prefix=...)``. This hoists the children of the inner duplicate into the
+  outer element and removes the inner wrapper.
+  """
+  for child in list(elem):
+    if child.tag == "default":
+      _collapse_defaults(child)
+  for child in list(elem):
+    if (
+      child.tag == "default"
+      and child.get("class") is not None
+      and len(child) == 1
+      and child[0].tag == "default"
+      and child[0].get("class") == child.get("class")
+    ):
+      inner = child[0]
+      child.remove(inner)
+      for grandchild in list(inner):
+        child.append(grandchild)
+      child.text = inner.text
+      if inner.tail:
+        last = list(child)[-1] if len(child) else None
+        if last is not None:
+          last.tail = (last.tail or "") + inner.tail
+
+
+def _remove_empty_defaults(elem: ET.Element) -> None:
+  """Remove empty ``<default/>`` and ``<default class="..."/>`` elements."""
+  for child in list(elem):
+    if child.tag == "default":
+      _remove_empty_defaults(child)
+      if len(child) == 0 and not (child.text and child.text.strip()):
+        elem.remove(child)
+
+
+def fix_spec_xml(xml: str, meshdir: str | None = None) -> str:
+  """Fix known issues in MjSpec.to_xml() output.
+
+  1. Remove empty ``<default/>`` and ``<default class="..."/>`` tags.
+  2. Collapse duplicate nested defaults with the same class name.
+  3. Optionally set ``meshdir`` in the ``<compiler>`` element.
+
+  Args:
+    xml: Raw XML string from ``MjSpec.to_xml()``.
+    meshdir: If provided, set ``meshdir`` on the ``<compiler>`` element.
+  """
+  root = ET.fromstring(xml)
+
+  for default_root in root.findall("default"):
+    _remove_empty_defaults(default_root)
+    _collapse_defaults(default_root)
+  # Remove top-level <default> if it ended up empty.
+  for default_root in list(root):
+    if default_root.tag == "default" and len(default_root) == 0:
+      root.remove(default_root)
+
+  if meshdir is not None:
+    compiler = root.find("compiler")
+    if compiler is not None:
+      compiler.set("meshdir", meshdir)
+
+  ET.indent(root, space="  ")
+  return ET.tostring(root, encoding="unicode", xml_declaration=False) + "\n"
diff --git a/src/mjlab/viewer/__init__.py b/src/mjlab/viewer/__init__.py
new file mode 100644
index 0000000..c0d6756
--- /dev/null
+++ b/src/mjlab/viewer/__init__.py
@@ -0,0 +1,10 @@
+"""Viewer module for environment visualization."""
+
+from mjlab.viewer.base import BaseViewer as BaseViewer
+from mjlab.viewer.base import EnvProtocol as EnvProtocol
+from mjlab.viewer.base import PolicyProtocol as PolicyProtocol
+from mjlab.viewer.base import VerbosityLevel as VerbosityLevel
+from mjlab.viewer.native import NativeMujocoViewer as NativeMujocoViewer
+from mjlab.viewer.offscreen_renderer import OffscreenRenderer as OffscreenRenderer
+from mjlab.viewer.viewer_config import ViewerConfig as ViewerConfig
+from mjlab.viewer.viser import ViserPlayViewer as ViserPlayViewer
diff --git a/src/mjlab/viewer/base.py b/src/mjlab/viewer/base.py
new file mode 100644
index 0000000..eb1f11b
--- /dev/null
+++ b/src/mjlab/viewer/base.py
@@ -0,0 +1,485 @@
+"""Base class for environment viewers.
+
+The viewer runs a policy against an RL environment and displays the
+result in real time.
+
+The Problem
+===========
+
+Each call to ``env.step()`` advances the simulation by a fixed amount
+of sim time (``step_dt``, set by the env config). The simplest viewer
+would call ``env.step()`` once per loop iteration, but iterations take
+however long the hardware needs. A fast machine loops 67 times per
+second and the simulation runs too fast; a slow machine loops 30 times
+and it runs too slow. Playback speed would depend on hardware.
+
+The viewer needs to answer a different question: given how much real
+time just elapsed, how many calls to ``env.step()`` will keep the
+simulation advancing at the right pace?
+
+Budget Accumulator
+==================
+
+A single variable, ``_sim_budget``, tracks how much sim time has
+accumulated but not yet been simulated. Each tick of the main loop:
+
+  1. Measure real time elapsed since the last tick.
+  2. Multiply by the speed setting and add to the budget.
+  3. Call ``env.step()`` in a loop, subtracting ``step_dt`` from the
+     budget each time, until the budget is less than one step.
+  4. Carry the leftover to the next tick.
+
+Example at 1x speed, step_dt = 0.02s (50 Hz control), 60 fps::
+
+  tick 1:  +0.0167s  ->  budget = 0.0167  ->  no step (< 0.02)
+  tick 2:  +0.0167s  ->  budget = 0.0334  ->  1 step, 0.0134 left
+  tick 3:  +0.0167s  ->  budget = 0.0301  ->  1 step, 0.0101 left
+  ...
+
+This averages to 50 steps per second on any hardware. At 2x speed the
+elapsed time is doubled before adding to the budget, so steps happen
+twice as often. At 0.5x, half as often.
+
+Rendering is independent: the display refreshes at ``frame_rate``
+(e.g. 60 Hz) whether or not a new step happened. Some frames will
+re-display the same state.
+
+If physics is too slow to keep up, the budget grows without bound. A
+real time deadline (one frame period) caps each burst so the renderer
+always gets a turn. Leftover budget is dropped and ``_was_capped`` is
+set.
+
+Main Loop
+=========
+
+::
+
+  run()
+    setup()
+    while running:
+      tick()                    -> True if a frame was produced
+        _process_actions()      drain UI action queue
+        _step_physics(dt)       accumulate budget, step until spent
+        sync_env_to_viewer()    push state to display (at frame_rate)
+      sleep(1ms)                yield CPU when no frame is due
+
+Subclasses implement setup(), sync_env_to_viewer(), sync_viewer_to_env(),
+close(), and is_running().
+"""
+
+from __future__ import annotations
+
+import signal
+import time
+import traceback
+from abc import ABC, abstractmethod
+from collections import deque
+from dataclasses import dataclass
+from enum import Enum, IntEnum
+from typing import TYPE_CHECKING, Any, Optional, Protocol
+
+import torch
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnvCfg
+
+
+class VerbosityLevel(IntEnum):
+  SILENT = 0
+  INFO = 1
+  DEBUG = 2
+
+
+class EnvProtocol(Protocol):
+  """Interface we expect from RL environments, which can be either vanilla
+  `ManagerBasedRlEnv` objects or wrapped with `VideoRecorder`,
+  `RslRlVecEnvWrapper`, etc."""
+
+  num_envs: int
+
+  @property
+  def device(self) -> torch.device | str: ...
+
+  @property
+  def cfg(self) -> ManagerBasedRlEnvCfg: ...
+
+  @property
+  def unwrapped(self) -> Any: ...
+
+  def get_observations(self) -> Any: ...
+  def step(self, actions: torch.Tensor) -> tuple[Any, ...]: ...
+  def reset(self) -> Any: ...
+  def close(self) -> None: ...
+
+
+class PolicyProtocol(Protocol):
+  def __call__(self, obs: torch.Tensor) -> torch.Tensor: ...
+
+
+@dataclass(frozen=True)
+class ViewerStatus:
+  paused: bool
+  step_count: int
+  speed_multiplier: float
+  speed_label: str
+  target_realtime: float
+  actual_realtime: float
+  smoothed_fps: float
+  capped: bool
+  last_error: str | None
+
+
+class ViewerAction(Enum):
+  RESET = "reset"
+  TOGGLE_PAUSE = "toggle_pause"
+  SINGLE_STEP = "single_step"
+  RESET_SPEED = "reset_speed"
+  SPEED_UP = "speed_up"
+  SPEED_DOWN = "speed_down"
+  PREV_ENV = "prev_env"
+  NEXT_ENV = "next_env"
+  TOGGLE_PLOTS = "toggle_plots"
+  TOGGLE_DEBUG_VIS = "toggle_debug_vis"
+  TOGGLE_SHOW_ALL_ENVS = "toggle_show_all_envs"
+  FETCH_CHECKPOINT = "fetch_checkpoint"
+  CUSTOM = "custom"
+
+
+class BaseViewer(ABC):
+  """Abstract base class for environment viewers."""
+
+  SPEED_MULTIPLIERS = [1 / 32, 1 / 16, 1 / 8, 1 / 4, 1 / 2, 1.0, 2.0, 4.0, 8.0]
+
+  def __init__(
+    self,
+    env: EnvProtocol,
+    policy: PolicyProtocol,
+    frame_rate: float = 30.0,
+    verbosity: int = VerbosityLevel.SILENT,
+  ):
+    self.env = env
+    self.policy = policy
+    self.frame_rate = frame_rate
+    self.frame_time = 1.0 / frame_rate
+    self.verbosity = VerbosityLevel(verbosity)
+    self.cfg = env.cfg.viewer
+
+    # State.
+    self._is_paused = False
+    self._step_count = 0
+    self._last_error: str | None = None
+
+    # Speed.
+    self._speed_index = self.SPEED_MULTIPLIERS.index(1.0)
+    self._time_multiplier = self.SPEED_MULTIPLIERS[self._speed_index]
+
+    # Physics accumulator and render timer.
+    self._sim_budget = 0.0
+    self._time_until_next_render = 0.0
+    self._last_tick_time = 0.0
+    self._was_capped = False
+
+    # Windowed stats, updated every 0.5s.
+    self._stats_frames = 0
+    self._stats_steps = 0
+    self._stats_last_time = 0.0
+    self._fps = 0.0
+    self._sps = 0.0
+
+    # Action queue, drained on main thread each tick.
+    self._actions: deque[tuple[ViewerAction, Optional[Any]]] = deque()
+
+  # Abstract hooks.
+
+  @abstractmethod
+  def setup(self) -> None: ...
+  @abstractmethod
+  def sync_env_to_viewer(self) -> None: ...
+  @abstractmethod
+  def sync_viewer_to_env(self) -> None: ...
+  @abstractmethod
+  def close(self) -> None: ...
+  @abstractmethod
+  def is_running(self) -> bool: ...
+
+  def _forward_paused(self) -> None:  # noqa: B027
+    """Hook for subclasses to run forward kinematics while paused."""
+
+  def _handle_custom_action(self, action: ViewerAction, payload: Optional[Any]) -> bool:
+    del action, payload
+    return False
+
+  # Logging.
+
+  def log(self, message: str, level: VerbosityLevel = VerbosityLevel.INFO) -> None:
+    if self.verbosity >= level:
+      print(message)
+
+  # Thread-safe action requests.
+
+  def request_reset(self) -> None:
+    self._actions.append((ViewerAction.RESET, None))
+
+  def request_toggle_pause(self) -> None:
+    self._actions.append((ViewerAction.TOGGLE_PAUSE, None))
+
+  def request_single_step(self) -> None:
+    self._actions.append((ViewerAction.SINGLE_STEP, None))
+
+  def request_speed_up(self) -> None:
+    self._actions.append((ViewerAction.SPEED_UP, None))
+
+  def request_speed_down(self) -> None:
+    self._actions.append((ViewerAction.SPEED_DOWN, None))
+
+  def request_reset_speed(self) -> None:
+    self._actions.append((ViewerAction.RESET_SPEED, None))
+
+  def request_action(self, name: str, payload: Optional[Any] = None) -> None:
+    try:
+      action = ViewerAction[name]
+    except KeyError:
+      action = ViewerAction.CUSTOM
+    self._actions.append((action, payload))
+
+  # Speed controls.
+
+  def increase_speed(self) -> None:
+    if self._speed_index < len(self.SPEED_MULTIPLIERS) - 1:
+      self._speed_index += 1
+      self._time_multiplier = self.SPEED_MULTIPLIERS[self._speed_index]
+
+  def decrease_speed(self) -> None:
+    if self._speed_index > 0:
+      self._speed_index -= 1
+      self._time_multiplier = self.SPEED_MULTIPLIERS[self._speed_index]
+
+  def reset_speed(self) -> None:
+    self._speed_index = self.SPEED_MULTIPLIERS.index(1.0)
+    self._time_multiplier = 1.0
+
+  # Pause and resume.
+
+  def pause(self) -> None:
+    self._is_paused = True
+    self.log("[INFO] Simulation paused", VerbosityLevel.INFO)
+
+  def resume(self) -> None:
+    self._is_paused = False
+    self._last_error = None
+    self._sim_budget = 0.0
+    self._last_tick_time = time.perf_counter()
+    self.log("[INFO] Simulation resumed", VerbosityLevel.INFO)
+
+  def toggle_pause(self) -> None:
+    if self._is_paused:
+      self.resume()
+    else:
+      self.pause()
+
+  # Core loop.
+
+  def _execute_step(self) -> bool:
+    """Run one obs/policy/step cycle.
+
+    Returns True on success, False if step failed.
+    """
+    try:
+      with torch.no_grad():
+        obs = self.env.get_observations()
+        actions = self.policy(obs)
+        self.env.step(actions)
+        self._step_count += 1
+        self._stats_steps += 1
+        return True
+    except Exception:
+      self._last_error = traceback.format_exc()
+      self.log(
+        f"[ERROR] Exception during step:\n{self._last_error}",
+        VerbosityLevel.SILENT,
+      )
+      self.pause()
+      return False
+
+  def _step_physics(self, dt: float) -> None:
+    """Run physics steps for this frame's sim-time budget."""
+    step_dt = self.env.unwrapped.step_dt
+    self._sim_budget += dt * self._time_multiplier
+    self._was_capped = False
+
+    if self._sim_budget < step_dt:
+      return
+
+    self.sync_viewer_to_env()
+    hit_deadline = False
+    deadline = time.perf_counter() + self.frame_time
+    while self._sim_budget >= step_dt:
+      if not self._execute_step():
+        self._sim_budget = 0.0
+        return
+      self._sim_budget -= step_dt
+      if time.perf_counter() > deadline:
+        hit_deadline = True
+        break
+
+    if hit_deadline:
+      # Only report capped if we actually had to drop remaining work. A transient stall
+      # (GC pause) during a single step triggers the deadline but leaves no remaining
+      # budget, so it's not a real cap.
+      self._was_capped = self._sim_budget >= step_dt
+      self._sim_budget = min(self._sim_budget, step_dt)
+
+  def _single_step(self) -> None:
+    """Advance exactly one step while paused."""
+    if not self._is_paused:
+      return
+    self.sync_viewer_to_env()
+    self._execute_step()
+
+  def reset_environment(self) -> None:
+    self.env.reset()
+    reset_fn = getattr(self.policy, "reset", None)
+    if reset_fn is not None:
+      reset_fn()
+    self._step_count = 0
+    self._sim_budget = 0.0
+    self._last_error = None
+    self._last_tick_time = time.perf_counter()
+
+  def _process_actions(self) -> None:
+    """Drain action queue. Runs on the main loop thread."""
+    while self._actions:
+      action, payload = self._actions.popleft()
+      if action == ViewerAction.RESET:
+        self.reset_environment()
+      elif action == ViewerAction.TOGGLE_PAUSE:
+        self.toggle_pause()
+      elif action == ViewerAction.SINGLE_STEP:
+        self._single_step()
+      elif action == ViewerAction.RESET_SPEED:
+        self.reset_speed()
+      elif action == ViewerAction.SPEED_UP:
+        self.increase_speed()
+      elif action == ViewerAction.SPEED_DOWN:
+        self.decrease_speed()
+      else:
+        _ = self._handle_custom_action(action, payload)
+
+  def tick(self) -> bool:
+    """Advance one tick: drain actions, step physics, maybe render.
+
+    Returns True when a render frame was produced, False otherwise.
+    """
+    now = time.perf_counter()
+    dt = now - self._last_tick_time
+    self._last_tick_time = now
+
+    self._process_actions()
+
+    if self._is_paused:
+      self._forward_paused()
+    else:
+      self._step_physics(dt)
+
+    # Render at fixed frame rate.
+    self._time_until_next_render -= dt
+    if self._time_until_next_render > 0:
+      return False
+
+    self._time_until_next_render += self.frame_time
+    if self._time_until_next_render < -self.frame_time:
+      self._time_until_next_render = 0.0
+
+    self.sync_env_to_viewer()
+    self._stats_frames += 1
+    return True
+
+  def run(self, num_steps: Optional[int] = None, catch_sigint: bool = True) -> None:
+    self._interrupted = False
+    self.setup()
+    now = time.perf_counter()
+    self._stats_last_time = now
+    self._last_tick_time = now
+
+    prev_handler = None
+    try:
+      if catch_sigint:
+        try:
+          prev_handler = signal.signal(signal.SIGINT, self._sigint_handler)
+        except ValueError:
+          pass  # Non-main thread; skip gracefully.
+
+      while (
+        self.is_running()
+        and (num_steps is None or self._step_count < num_steps)
+        and not self._interrupted
+      ):
+        if not self.tick():
+          time.sleep(0.001)
+        self._update_stats()
+    finally:
+      self.close()
+      if prev_handler is not None:
+        signal.signal(signal.SIGINT, prev_handler)
+
+  def _sigint_handler(self, signum, frame) -> None:
+    self._interrupted = True
+    print("\nCtrl+C received. Shutting down viewer...")
+    # Restore default so a second Ctrl+C kills immediately.
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
+
+  # Stats.
+
+  def _update_stats(self) -> None:
+    if self._is_paused:
+      return
+    now = time.perf_counter()
+    dt = now - self._stats_last_time
+    if dt >= 0.5:
+      self._fps = self._stats_frames / dt
+      self._sps = self._stats_steps / dt
+      self._stats_frames = 0
+      self._stats_steps = 0
+      self._stats_last_time = now
+
+      if self.verbosity >= VerbosityLevel.DEBUG:
+        status = self.get_status()
+        print(
+          f"[{'PAUSED' if status.paused else 'RUNNING'}] "
+          f"Step {status.step_count} | "
+          f"FPS: {status.smoothed_fps:.0f} | "
+          f"Speed: {status.speed_label} | "
+          f"RTF: {status.actual_realtime:.2f}x / "
+          f"{status.target_realtime:.2f}x"
+        )
+
+  @property
+  def target_realtime(self) -> float:
+    return self._time_multiplier
+
+  @property
+  def actual_realtime(self) -> float:
+    return self._sps * self.env.unwrapped.step_dt
+
+  @staticmethod
+  def _format_speed(multiplier: float) -> str:
+    if multiplier == 1.0:
+      return "1x"
+    inv = 1.0 / multiplier
+    inv_rounded = round(inv)
+    if abs(inv - inv_rounded) < 1e-9 and inv_rounded > 0:
+      return f"1/{inv_rounded}x"
+    return f"{multiplier:.3g}x"
+
+  def get_status(self) -> ViewerStatus:
+    return ViewerStatus(
+      paused=self._is_paused,
+      step_count=self._step_count,
+      speed_multiplier=self._time_multiplier,
+      speed_label=self._format_speed(self._time_multiplier),
+      target_realtime=self.target_realtime,
+      actual_realtime=self.actual_realtime,
+      smoothed_fps=self._fps,
+      capped=self._was_capped,
+      last_error=self._last_error,
+    )
diff --git a/src/mjlab/viewer/debug_visualizer.py b/src/mjlab/viewer/debug_visualizer.py
new file mode 100644
index 0000000..32050c8
--- /dev/null
+++ b/src/mjlab/viewer/debug_visualizer.py
@@ -0,0 +1,269 @@
+"""Abstract interface for debug visualization across different viewers."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+if TYPE_CHECKING:
+  import mujoco
+
+
+class DebugVisualizer(ABC):
+  """Abstract base class for viewer-agnostic debug visualization.
+
+  This allows manager terms to draw debug visualizations without knowing the underlying
+  viewer implementation.
+  """
+
+  env_idx: int
+  """Index of the environment being visualized."""
+
+  show_all_envs: bool
+  """If True, visualize all environments instead of just env_idx."""
+
+  def get_env_indices(self, num_envs: int) -> Iterable[int]:
+    """Get the environment indices to visualize.
+
+    This helper method handles the show_all_envs logic so implementations
+    don't need to repeat this boilerplate.
+
+    Args:
+      num_envs: Total number of environments.
+
+    Returns:
+      An iterable of environment indices to visualize.
+    """
+    if self.show_all_envs:
+      return range(num_envs)
+    elif self.env_idx < num_envs:
+      return [self.env_idx]
+    else:
+      return []
+
+  @property
+  @abstractmethod
+  def meansize(self) -> float:
+    """Mean size of the model, used for scaling visualization elements."""
+    ...
+
+  @abstractmethod
+  def add_arrow(
+    self,
+    start: np.ndarray,
+    end: np.ndarray,
+    color: tuple[float, float, float, float],
+    width: float = 0.015,
+    label: str | None = None,
+  ) -> None:
+    """Add an arrow from start to end position.
+
+    Args:
+      start: Start position (3D vector).
+      end: End position (3D vector).
+      color: RGBA color (values 0-1).
+      width: Arrow shaft width.
+      label: Optional label for this arrow.
+    """
+    ...
+
+  @abstractmethod
+  def add_ghost_mesh(
+    self,
+    qpos: np.ndarray,
+    model: mujoco.MjModel,
+    mocap_pos: np.ndarray | None = None,
+    mocap_quat: np.ndarray | None = None,
+    alpha: float = 0.5,
+    label: str | None = None,
+  ) -> None:
+    """Add a ghost/transparent rendering of a robot at a target pose.
+
+    Args:
+      qpos: Joint positions for the ghost pose.
+      model: MuJoCo model with pre-configured appearance (geom_rgba for colors).
+      mocap_pos: Optional mocap position(s) for fixed-base entities.
+      mocap_quat: Optional mocap quaternion(s) for fixed-base entities.
+      alpha: Transparency override (0=transparent, 1=opaque). May not be supported by
+        all implementations.
+      label: Optional label for this ghost.
+    """
+    ...
+
+  @abstractmethod
+  def add_frame(
+    self,
+    position: np.ndarray,
+    rotation_matrix: np.ndarray,
+    scale: float = 0.3,
+    label: str | None = None,
+    axis_radius: float = 0.01,
+    alpha: float = 1.0,
+    axis_colors: tuple[tuple[float, float, float], ...] | None = None,
+  ) -> None:
+    """Add a coordinate frame visualization.
+
+    Args:
+      position: Position of the frame origin (3D vector).
+      rotation_matrix: Rotation matrix (3x3).
+      scale: Scale/length of the axis arrows.
+      label: Optional label for this frame.
+      axis_radius: Radius/thickness of the axis arrows.
+      alpha: Transparency override (0=transparent, 1=opaque). Note: The Viser
+        implementation does not support per-arrow transparency. All arrows in the
+        scene will share the same alpha value.
+      axis_colors: Optional tuple of 3 RGB colors for X, Y, Z axes. Each color is a
+        tuple of 3 floats (R, G, B) with values 0-1. If None, uses default RGB coloring
+        (X=red, Y=green, Z=blue).
+    """
+    ...
+
+  @abstractmethod
+  def add_sphere(
+    self,
+    center: np.ndarray,
+    radius: float,
+    color: tuple[float, float, float, float],
+    label: str | None = None,
+  ) -> None:
+    """Add a sphere visualization.
+
+    Args:
+      center: Center position (3D vector).
+      radius: Sphere radius.
+      color: RGBA color (values 0-1).
+      label: Optional label for this sphere.
+    """
+    ...
+
+  @abstractmethod
+  def add_cylinder(
+    self,
+    start: np.ndarray,
+    end: np.ndarray,
+    radius: float,
+    color: tuple[float, float, float, float],
+    label: str | None = None,
+  ) -> None:
+    """Add a cylinder visualization.
+
+    Args:
+      start: Bottom center position (3D vector).
+      end: Top center position (3D vector).
+      radius: Cylinder radius.
+      color: RGBA color (values 0-1).
+      label: Optional label for this cylinder.
+    """
+    ...
+
+  @abstractmethod
+  def add_ellipsoid(
+    self,
+    center: np.ndarray,
+    size: np.ndarray,
+    mat: np.ndarray,
+    color: tuple[float, float, float, float],
+    label: str | None = None,
+  ) -> None:
+    """Add an ellipsoid visualization.
+
+    Args:
+      center: Center position (3D vector).
+      size: Semi-axes lengths (3D vector: a, b, c).
+      mat: 3x3 rotation matrix (or flattened 9-element array).
+      color: RGBA color (values 0-1).
+      label: Optional label for this ellipsoid.
+    """
+    ...
+
+  @abstractmethod
+  def add_box(
+    self,
+    center: np.ndarray,
+    size: np.ndarray,
+    mat: np.ndarray,
+    color: tuple[float, float, float, float],
+    label: str | None = None,
+  ) -> None:
+    """Add an axis-oriented box visualization.
+
+    Args:
+      center: Center position (3D vector).
+      size: Half-extents along each local axis (3D vector: a, b, c).
+      mat: 3x3 rotation matrix (or flattened 9-element array).
+      color: RGBA color (values 0-1).
+      label: Optional label for this box.
+    """
+    ...
+
+  @abstractmethod
+  def clear(self) -> None:
+    """Clear all debug visualizations."""
+    ...
+
+
+class NullDebugVisualizer:
+  """No-op visualizer when visualization is disabled."""
+
+  def __init__(self, env_idx: int = 0, meansize: float = 0.1):
+    self.env_idx = env_idx
+    self.show_all_envs = False
+    self._meansize = meansize
+
+  def get_env_indices(self, num_envs: int) -> Iterable[int]:
+    """Get the environment indices to visualize."""
+    if self.show_all_envs:
+      return range(num_envs)
+    elif self.env_idx < num_envs:
+      return [self.env_idx]
+    else:
+      return []
+
+  @property
+  def meansize(self) -> float:
+    return self._meansize
+
+  def add_arrow(self, start, end, color, width=0.015, label=None) -> None:
+    pass
+
+  def add_ghost_mesh(
+    self,
+    qpos,
+    model,
+    mocap_pos=None,
+    mocap_quat=None,
+    alpha=0.5,
+    label=None,
+  ) -> None:
+    del mocap_pos, mocap_quat
+    pass
+
+  def add_frame(
+    self,
+    position,
+    rotation_matrix,
+    scale=0.3,
+    label=None,
+    axis_radius=0.01,
+    alpha=1.0,
+    axis_colors=None,
+  ) -> None:
+    pass
+
+  def add_sphere(self, center, radius, color, label=None) -> None:
+    pass
+
+  def add_cylinder(self, start, end, radius, color, label=None) -> None:
+    pass
+
+  def add_ellipsoid(self, center, size, mat, color, label=None) -> None:
+    pass
+
+  def add_box(self, center, size, mat, color, label=None) -> None:
+    pass
+
+  def clear(self) -> None:
+    pass
diff --git a/src/mjlab/viewer/model_sync.py b/src/mjlab/viewer/model_sync.py
new file mode 100644
index 0000000..94a7876
--- /dev/null
+++ b/src/mjlab/viewer/model_sync.py
@@ -0,0 +1,97 @@
+"""Shared helpers for syncing per-world model fields into a host MjModel.
+
+The simulator owns one CPU MjModel as a template for MuJoCo host APIs, while
+mjlab.sim.Simulation.model may hold per-world arrays after domain randomization
+or per-world mesh compilation. Viewers and renderers must copy the target env's
+fields into their host model before calling CPU MuJoCo rendering or kinematics
+functions.
+
+Used by the native / offscreen / viser viewers.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import mujoco
+
+# Inertial fields that shift subtree_com (and thus the tracking camera).
+VIEWER_INERTIAL_FIELDS = frozenset({"body_ipos", "body_mass"})
+
+# Fields that affect viewer-side CPU rendering or kinematics. Physics-only
+# fields (geom_aabb, geom_rbound, dof_*, jnt_*, actuator_*, tendon_*,
+# body_invweight0) are skipped.
+VIEWER_MODEL_FIELDS = frozenset(
+  {
+    "qpos0",  # Needed for correct mj_forward kinematics (qpos - qpos0).
+    "geom_dataid",  # Per-world mesh variants.
+    "geom_matid",  # Per-world material variants.
+    "geom_rgba",
+    "geom_size",
+    "geom_pos",
+    "geom_quat",
+    "mat_emission",
+    "mat_rgba",
+    "mat_shininess",
+    "mat_specular",
+    "mat_texid",
+    "mat_texrepeat",
+    "site_pos",
+    "site_quat",
+    "body_pos",
+    "body_quat",
+    "body_ipos",
+    "body_inertia",
+    "body_iquat",
+    "body_mass",
+    # body_subtreemass is the denominator mj_forward uses to normalize
+    # subtree_com. Without it, the mjVIS_COM decor geoms (and any code that
+    # reads data.subtree_com) land at scaled/arbitrary positions when
+    # body_mass varies per-world.
+    "body_subtreemass",
+    "cam_pos",
+    "cam_quat",
+    "cam_fovy",
+    "cam_intrinsic",
+    "light_pos",
+    "light_dir",
+    "light_ambient",
+    "light_diffuse",
+    "light_specular",
+    "light_attenuation",
+    "light_cutoff",
+    "light_exponent",
+  }
+)
+
+
+def disable_model_sameframe_shortcuts(model: mujoco.MjModel) -> None:
+  """Force MuJoCo's host model down the full local-to-global transform path.
+
+  mujoco_warp does not implement MuJoCo's *_sameframe shortcuts: its
+  kinematics kernels always apply the full transform for inertial frames,
+  geoms, and sites. Clearing these compile-time flags on the CPU viewer model
+  keeps host-side mj_forward consistent with the GPU path when per-world
+  mesh variants change local offsets and frame alignments.
+  """
+  none = mujoco.mjtSameFrame.mjSAMEFRAME_NONE.value
+  model.body_sameframe[:] = none
+  model.geom_sameframe[:] = none
+  model.site_sameframe[:] = none
+  # body_simple is another compile-time shortcut derived from body_sameframe.
+  # Clear it too so host-side inertia code does not
+  # assume the original compiled alignment.
+  model.body_simple[:] = 0
+
+
+def sync_model_fields(
+  dst_model: mujoco.MjModel,
+  sim_model: Any,
+  fields: set[str] | frozenset[str],
+  env_idx: int,
+) -> None:
+  """Copy per-world model fields from sim_model[env_idx] into dst_model."""
+  for field_name in fields:
+    src = getattr(sim_model, field_name)[env_idx].cpu().numpy()
+    dst = getattr(dst_model, field_name)
+    dst[:] = src.reshape(dst.shape)
diff --git a/src/mjlab/viewer/native/__init__.py b/src/mjlab/viewer/native/__init__.py
new file mode 100644
index 0000000..a684d69
--- /dev/null
+++ b/src/mjlab/viewer/native/__init__.py
@@ -0,0 +1,6 @@
+"""Native MuJoCo viewer implementation."""
+
+from mjlab.viewer.native.viewer import NativeMujocoViewer as NativeMujocoViewer
+from mjlab.viewer.native.visualizer import (
+  MujocoNativeDebugVisualizer as MujocoNativeDebugVisualizer,
+)
diff --git a/src/mjlab/viewer/native/keys.py b/src/mjlab/viewer/native/keys.py
new file mode 100644
index 0000000..e277c01
--- /dev/null
+++ b/src/mjlab/viewer/native/keys.py
@@ -0,0 +1,107 @@
+"""Key codes for input handling."""
+
+KEY_UNKNOWN = -1
+KEY_SPACE = 32
+KEY_APOSTROPHE = 39
+KEY_COMMA = 44
+KEY_MINUS = 45
+KEY_PERIOD = 46
+KEY_SLASH = 47
+KEY_0 = 48
+KEY_1 = 49
+KEY_2 = 50
+KEY_3 = 51
+KEY_4 = 52
+KEY_5 = 53
+KEY_6 = 54
+KEY_7 = 55
+KEY_8 = 56
+KEY_9 = 57
+KEY_SEMICOLON = 59
+KEY_EQUAL = 61
+KEY_A = 65
+KEY_B = 66
+KEY_C = 67
+KEY_D = 68
+KEY_E = 69
+KEY_F = 70
+KEY_G = 71
+KEY_H = 72
+KEY_I = 73
+KEY_J = 74
+KEY_K = 75
+KEY_L = 76
+KEY_M = 77
+KEY_N = 78
+KEY_O = 79
+KEY_P = 80
+KEY_Q = 81
+KEY_R = 82
+KEY_S = 83
+KEY_T = 84
+KEY_U = 85
+KEY_V = 86
+KEY_W = 87
+KEY_X = 88
+KEY_Y = 89
+KEY_Z = 90
+KEY_LEFT_BRACKET = 91
+KEY_BACKSLASH = 92
+KEY_RIGHT_BRACKET = 93
+KEY_GRAVE_ACCENT = 96
+KEY_ESCAPE = 256
+KEY_ENTER = 257
+KEY_TAB = 258
+KEY_BACKSPACE = 259
+KEY_INSERT = 260
+KEY_DELETE = 261
+KEY_RIGHT = 262
+KEY_LEFT = 263
+KEY_DOWN = 264
+KEY_UP = 265
+KEY_PAGE_UP = 266
+KEY_PAGE_DOWN = 267
+KEY_HOME = 268
+KEY_END = 269
+KEY_CAPS_LOCK = 280
+KEY_SCROLL_LOCK = 281
+KEY_NUM_LOCK = 282
+KEY_PRINT_SCREEN = 283
+KEY_PAUSE = 284
+KEY_F1 = 290
+KEY_F2 = 291
+KEY_F3 = 292
+KEY_F4 = 293
+KEY_F5 = 294
+KEY_F6 = 295
+KEY_F7 = 296
+KEY_F8 = 297
+KEY_F9 = 298
+KEY_F10 = 299
+KEY_F11 = 300
+KEY_F12 = 301
+KEY_KP_0 = 320
+KEY_KP_1 = 321
+KEY_KP_2 = 322
+KEY_KP_3 = 323
+KEY_KP_4 = 324
+KEY_KP_5 = 325
+KEY_KP_6 = 326
+KEY_KP_7 = 327
+KEY_KP_8 = 328
+KEY_KP_9 = 329
+KEY_KP_DECIMAL = 330
+KEY_KP_DIVIDE = 331
+KEY_KP_MULTIPLY = 332
+KEY_KP_SUBTRACT = 333
+KEY_KP_ADD = 334
+KEY_KP_ENTER = 335
+KEY_KP_EQUAL = 336
+KEY_LEFT_SHIFT = 340
+KEY_LEFT_CONTROL = 341
+KEY_LEFT_ALT = 342
+KEY_LEFT_SUPER = 343
+KEY_RIGHT_SHIFT = 344
+KEY_RIGHT_CONTROL = 345
+KEY_RIGHT_ALT = 346
+KEY_RIGHT_SUPER = 347
diff --git a/src/mjlab/viewer/native/viewer.py b/src/mjlab/viewer/native/viewer.py
new file mode 100644
index 0000000..57743cb
--- /dev/null
+++ b/src/mjlab/viewer/native/viewer.py
@@ -0,0 +1,750 @@
+"""Environment viewer built on MuJoCo's passive viewer.
+
+Overview
+--------
+The simulation runs on the GPU via mujoco_warp, but MuJoCo's passive viewer
+requires CPU ``MjModel`` and ``MjData`` structures. Each frame, this module
+copies the GPU state for one environment into CPU buffers, calls
+``mj_forward`` to recompute kinematics and contacts, and hands the result to
+the render thread via ``v.sync()``. Contacts visible in the viewer are
+computed by C MuJoCo on the CPU, not by mujoco_warp on the GPU.
+
+The per frame sync has four steps:
+
+1. ``_sync_env_state_to_mjdata``: copy ``qpos``, ``qvel``, ``mocap``, and
+   ``xfrc_applied`` from GPU tensors into CPU ``MjData``.
+2. ``mj_forward``: recompute kinematics, collisions, and derived quantities.
+3. ``_sync_model_fields``: if domain randomization expanded visual fields
+   (geom colors, body poses, camera parameters, etc.), copy the per world
+   values from GPU ``sim.model`` into CPU ``MjModel``.
+4. ``v.sync()``: hand ``MjModel``/``MjData`` to the passive viewer's render
+   thread.
+
+For multi environment scenes, steps 1 and 2 are repeated for neighboring
+environments into a secondary ``MjData`` (``self.vd``), and their geoms are
+injected via ``mjv_addGeoms``.
+
+External force channels
+-----------------------
+MuJoCo sums two external force inputs during forward dynamics:
+
+* ``xfrc_applied``: Cartesian forces per body (GPU to CPU, for rendering).
+* ``qfrc_applied``: generalized forces per DoF (CPU to GPU, for mouse input).
+
+Programmatic forces (e.g. ``apply_body_impulse``) write to ``xfrc_applied``
+on the GPU and flow one way to the CPU ``MjData`` for visualization. Mouse
+perturbation forces flow the opposite direction: the viewer computes them on
+the CPU via ``mjv_applyPerturbForce``, converts to joint space with
+``mj_applyFT``, and writes to ``qfrc_applied`` on the GPU. Each field flows
+in one direction only, so the two sources never overwrite each other.
+"""
+
+from __future__ import annotations
+
+import math
+from collections import deque
+from dataclasses import dataclass
+from threading import Lock
+from typing import TYPE_CHECKING, Callable, Optional, Protocol
+
+import mujoco
+import mujoco.viewer
+import numpy as np
+import torch
+
+from mjlab.viewer.base import (
+  BaseViewer,
+  EnvProtocol,
+  PolicyProtocol,
+  VerbosityLevel,
+  ViewerAction,
+)
+from mjlab.viewer.model_sync import (
+  VIEWER_INERTIAL_FIELDS,
+  VIEWER_MODEL_FIELDS,
+  disable_model_sameframe_shortcuts,
+  sync_model_fields,
+)
+from mjlab.viewer.native.visualizer import MujocoNativeDebugVisualizer
+
+if TYPE_CHECKING:
+  from mjlab.entity import Entity
+
+
+@dataclass(frozen=True)
+class PlotCfg:
+  """Reward plot configuration."""
+
+  history: int = 300  # Points kept per series.
+  p_lo: float = 2.0  # Percentile low.
+  p_hi: float = 98.0  # Percentile high.
+  pad: float = 0.25  # Pad % of span on both sides.
+  min_span: float = 1e-6  # Minimum vertical span.
+  init_yrange: tuple[float, float] = (-0.01, 0.01)  # Initial y-range.
+  grid_size: tuple[int, int] = (3, 4)  # Grid size (rows, columns).
+  max_viewports: int = 12  # Cap number of plots shown.
+  min_rows_per_col: int = 4  # Minimum rows for height calc (prevents stretching).
+  max_rows_per_col: int = 6  # Stack up to this many per column.
+  plot_strip_fraction: float = 1 / 3  # Right-side width reserved for plots.
+  background_alpha: float = 0.5  # Background alpha for plots.
+
+
+class _SimDataProtocol(Protocol):
+  qpos: "_TensorArrayProtocol"
+  qvel: "_TensorArrayProtocol"
+  mocap_pos: "_TensorArrayProtocol"
+  mocap_quat: "_TensorArrayProtocol"
+  ctrl: "_TensorArrayProtocol"
+  xfrc_applied: "_TensorArrayProtocol"
+  qfrc_applied: "_TensorArrayProtocol"
+
+
+class _CpuArrayProtocol(Protocol):
+  def cpu(self) -> "_CpuArrayProtocol": ...
+  def numpy(self) -> np.ndarray: ...
+
+
+class _TensorArrayProtocol(Protocol):
+  def __getitem__(self, idx: int) -> _CpuArrayProtocol: ...
+
+
+class _SimModelProtocol(Protocol):
+  def __getattr__(self, name: str) -> object: ...
+
+
+class _SimProtocol(Protocol):
+  data: _SimDataProtocol
+  model: _SimModelProtocol
+  expanded_fields: set[str]
+
+
+class NativeMujocoViewer(BaseViewer):
+  def __init__(
+    self,
+    env: EnvProtocol,
+    policy: PolicyProtocol,
+    frame_rate: float = 60.0,
+    key_callback: Optional[Callable[[int], None]] = None,
+    plot_cfg: PlotCfg | None = None,
+    enable_perturbations: bool = True,
+    verbosity: VerbosityLevel = VerbosityLevel.SILENT,
+  ):
+    super().__init__(env, policy, frame_rate, verbosity)
+    self.user_key_callback = key_callback
+    self.enable_perturbations = enable_perturbations
+
+    self.mjm: Optional[mujoco.MjModel] = None
+    self.mjd: Optional[mujoco.MjData] = None
+    self.viewer: Optional[mujoco.viewer.Handle] = None
+    self.vd: Optional[mujoco.MjData] = None
+    self.vopt: Optional[mujoco.MjvOption] = None
+    self.pert: Optional[mujoco.MjvPerturb] = None
+    self.catmask: int = mujoco.mjtCatBit.mjCAT_DYNAMIC.value
+
+    self._term_names: list[str] = []
+    self._figures: dict[str, mujoco.MjvFigure] = {}  # Per-term figure.
+    self._histories: dict[str, deque[float]] = {}  # Per-term ring buffer.
+    self._yrange: dict[str, tuple[float, float]] = {}  # Per-term y-range.
+    self._scale: dict[str, float] = {}  # Per-term display scale factor.
+    self._show_plots: bool = False
+    self._show_debug_vis: bool = True
+    self._show_all_envs: bool = False
+    self._plot_cfg = plot_cfg or PlotCfg()
+    self._figures_dirty: bool = False
+
+    self.env_idx = self.cfg.env_idx
+    self._mj_lock = Lock()
+
+  def setup(self) -> None:
+    """Setup MuJoCo viewer resources."""
+    sim = self.env.unwrapped.sim
+    self.mjm = sim.mj_model
+    self.mjd = sim.mj_data
+    assert self.mjm is not None
+    disable_model_sameframe_shortcuts(self.mjm)
+    if self.cfg.fovy is not None:
+      self.mjm.vis.global_.fovy = self.cfg.fovy
+
+    if self.env.unwrapped.num_envs > 1:
+      self.vd = mujoco.MjData(self.mjm)
+
+    self.pert = mujoco.MjvPerturb() if self.enable_perturbations else None
+    self.vopt = mujoco.MjvOption()
+
+    self._term_names = [
+      name
+      for name, _ in self.env.unwrapped.reward_manager.get_active_iterable_terms(
+        self.env_idx
+      )
+    ]
+    self._init_reward_plots(self._term_names)
+
+    assert self.mjm is not None
+    assert self.mjd is not None
+    self.viewer = mujoco.viewer.launch_passive(
+      self.mjm,
+      self.mjd,
+      key_callback=self._safe_key_callback,
+      show_left_ui=False,
+      show_right_ui=False,
+    )
+    if self.viewer is None:
+      raise RuntimeError("Failed to launch MuJoCo viewer")
+
+    if not self.cfg.enable_shadows:
+      self.viewer.user_scn.flags[mujoco.mjtRndFlag.mjRND_SHADOW] = 0
+
+    self.viewer.opt.flags[mujoco.mjtVisFlag.mjVIS_SCLINERTIA] = 1
+
+    self._setup_camera()
+
+    if self.enable_perturbations:
+      self.log("[INFO] Interactive perturbations enabled", VerbosityLevel.INFO)
+
+  def is_running(self) -> bool:
+    return bool(self.viewer and self.viewer.is_running())
+
+  def sync_env_to_viewer(self) -> None:
+    """Copy env state to viewer; update reward figures; render other envs."""
+    v = self.viewer
+    assert v is not None
+    assert self.mjm is not None and self.mjd is not None and self.vopt is not None
+
+    # Window may have been closed between is_running() check and here.
+    if not v.is_running():
+      return
+
+    with self._mj_lock:
+      sim = self.env.unwrapped.sim
+      sim_data = sim.data
+      self._sync_env_state_to_mjdata(self.mjd, sim_data, self.env_idx)
+      self._sync_model_fields(sim, self.env_idx)
+      mujoco.mj_forward(self.mjm, self.mjd)
+
+      # The viewer window can close at any time. Re-check before set_texts
+      # / set_figures since those use spin-wait sync with the render loop.
+      if not v.is_running():
+        return
+      self._set_status_overlay(v)
+      if not v.is_running():
+        return
+      self._update_reward_figures(v)
+
+      self._update_debug_visualizers(v)
+      self._add_env_selection_marker(v)
+      self._render_other_env_geoms(v, sim, sim_data)
+
+      # Pin tracking camera to body frame origin so DR-induced COM shifts don't move
+      # the camera.
+      if sim.expanded_fields & VIEWER_INERTIAL_FIELDS:
+        self._stabilize_tracking_camera()
+
+      has_visual_dr = bool(sim.expanded_fields & VIEWER_MODEL_FIELDS)
+      v.sync(state_only=not has_visual_dr)
+
+  def _set_status_overlay(self, viewer: mujoco.viewer.Handle) -> None:
+    status = self.get_status()
+    capped = " [CAPPED]" if status.capped else ""
+    text_1 = "Env\nStep\nStatus\nSpeed\nTarget RT\nActual RT"
+    text_2 = (
+      f"{self.env_idx + 1}/{self.env.num_envs}\n"
+      f"{status.step_count}\n"
+      f"{'PAUSED' if status.paused else 'RUNNING'}{capped}\n"
+      f"{status.speed_label}\n"
+      f"{status.target_realtime:.2f}x\n"
+      f"{status.actual_realtime:.2f}x ({status.smoothed_fps:.0f} FPS)"
+    )
+    overlay = (
+      mujoco.mjtFontScale.mjFONTSCALE_150.value,
+      mujoco.mjtGridPos.mjGRID_TOPLEFT.value,
+      text_1,
+      text_2,
+    )
+    viewer.set_texts(overlay)
+
+  def _update_reward_figures(self, viewer: mujoco.viewer.Handle) -> None:
+    if not self._show_plots or not self._term_names:
+      # Only send an empty set_figures when transitioning from shown to hidden, to
+      # avoid a spin-wait round trip every frame.
+      if self._figures_dirty:
+        viewer.set_figures([])
+        self._figures_dirty = False
+      return
+
+    terms = list(
+      self.env.unwrapped.reward_manager.get_active_iterable_terms(self.env_idx)
+    )
+    if not self._is_paused:
+      for name, arr in terms:
+        if name in self._histories:
+          self._append_point(name, float(arr[0]))
+          self._write_history_to_figure(name)
+
+    viewports = compute_viewports(
+      len(self._term_names), viewer.viewport, self._plot_cfg
+    )
+    viewport_figs = [
+      (viewports[i], self._figures[self._term_names[i]])
+      for i in range(
+        min(len(viewports), len(self._term_names), self._plot_cfg.max_viewports)
+      )
+    ]
+    viewer.set_figures(viewport_figs)
+    self._figures_dirty = True
+
+  def _update_debug_visualizers(self, viewer: mujoco.viewer.Handle) -> None:
+    viewer.user_scn.ngeom = 0
+    if self._show_debug_vis and hasattr(self.env.unwrapped, "update_visualizers"):
+      assert self.mjm is not None
+      visualizer = MujocoNativeDebugVisualizer(
+        viewer.user_scn, self.mjm, self.env_idx, self._show_all_envs
+      )
+      self.env.unwrapped.update_visualizers(visualizer)
+
+  def _add_env_selection_marker(self, viewer: mujoco.viewer.Handle) -> None:
+    """Draw a downward arrow above the selected environment."""
+    if self.env.unwrapped.num_envs <= 1:
+      return
+    assert self.mjd is not None and self.mjm is not None
+    last = self.mjm.nbody - 1
+    center = self.mjd.xpos[max(last, 1)].copy()
+    arrow_top = center + np.array([0.0, 0.0, 0.4])
+    arrow_bottom = center + np.array([0.0, 0.0, 0.15])
+    scn = viewer.user_scn
+    if scn.ngeom >= scn.maxgeom:
+      return
+    scn.ngeom += 1
+    geom = scn.geoms[scn.ngeom - 1]
+    geom.category = mujoco.mjtCatBit.mjCAT_DECOR
+    mujoco.mjv_initGeom(
+      geom=geom,
+      type=mujoco.mjtGeom.mjGEOM_ARROW.value,
+      size=np.zeros(3),
+      pos=np.zeros(3),
+      mat=np.zeros(9),
+      rgba=np.array([1.0, 0.2, 0.2, 0.8], dtype=np.float32),
+    )
+    mujoco.mjv_connector(
+      geom=geom,
+      type=mujoco.mjtGeom.mjGEOM_ARROW.value,
+      width=0.02,
+      from_=arrow_top,
+      to=arrow_bottom,
+    )
+
+  def _sync_env_state_to_mjdata(
+    self, target_data: mujoco.MjData, sim_data: _SimDataProtocol, env_idx: int
+  ) -> None:
+    """Copy one environment state from batched sim data into a MjData buffer."""
+    assert self.mjm is not None
+    if self.mjm.nq > 0:
+      target_data.qpos[:] = sim_data.qpos[env_idx].cpu().numpy()
+      target_data.qvel[:] = sim_data.qvel[env_idx].cpu().numpy()
+    if self.mjm.nu > 0:
+      target_data.ctrl[:] = sim_data.ctrl[env_idx].cpu().numpy()
+    if self.mjm.nmocap > 0:
+      target_data.mocap_pos[:] = sim_data.mocap_pos[env_idx].cpu().numpy()
+      target_data.mocap_quat[:] = sim_data.mocap_quat[env_idx].cpu().numpy()
+    target_data.xfrc_applied[:] = sim_data.xfrc_applied[env_idx].cpu().numpy()
+
+  def _render_other_env_geoms(
+    self,
+    viewer: mujoco.viewer.Handle,
+    sim: _SimProtocol,
+    sim_data: _SimDataProtocol,
+  ) -> None:
+    """Render non-selected environments into the native viewer scene."""
+    if self.vd is None:
+      return
+    assert self.mjm is not None
+    assert self.vopt is not None
+    assert self.pert is not None
+
+    for i in range(self.env.unwrapped.num_envs):
+      if i == self.env_idx:
+        continue
+      self._sync_env_state_to_mjdata(self.vd, sim_data, i)
+      self._sync_model_fields(sim, i)
+      mujoco.mj_forward(self.mjm, self.vd)
+      mujoco.mjv_addGeoms(
+        self.mjm, self.vd, self.vopt, self.pert, self.catmask, viewer.user_scn
+      )
+
+    # Restore main env's model fields.
+    self._sync_model_fields(sim, self.env_idx)
+
+  def _sync_model_fields(self, sim: _SimProtocol, env_idx: int) -> None:
+    """Sync visually-relevant DR'd model fields from GPU to MjModel."""
+    assert self.mjm is not None
+    fields = sim.expanded_fields & VIEWER_MODEL_FIELDS
+    sync_model_fields(self.mjm, sim.model, fields, env_idx)
+
+  def _stabilize_tracking_camera(self) -> None:
+    """Pin the tracked body's subtree_com to its frame origin (xpos).
+
+    MuJoCo's tracking camera centers on ``subtree_com[trackbodyid]``, which
+    shifts when inertial fields (body_ipos, body_mass) are domain randomized.
+    Overwriting that single entry with ``xpos`` (the body frame origin,
+    unaffected by body_ipos) keeps the camera stable.
+    """
+    assert self.mjd is not None
+    if not (
+      self.viewer and self.viewer.cam.type == mujoco.mjtCamera.mjCAMERA_TRACKING.value
+    ):
+      return
+    bid = self.viewer.cam.trackbodyid
+    if bid >= 0:
+      self.mjd.subtree_com[bid] = self.mjd.xpos[bid]
+
+  def sync_viewer_to_env(self) -> None:
+    """Sync mouse perturbation to sim via ``qfrc_applied``.
+
+    Mouse perturbation forces are converted from Cartesian body space
+    (``xfrc_applied``) to generalized joint space (``qfrc_applied``)
+    so that they coexist with programmatic forces on ``xfrc_applied``.
+    See the module docstring for details on the channel separation.
+    """
+    v = self.viewer
+    if v is None or self.mjm is None or self.mjd is None:
+      return
+
+    sim_data = self.env.unwrapped.sim.data
+    pert = v.perturb
+
+    if pert.active != 0 and pert.select > 0:
+      # Compute mouse perturbation force in Cartesian space.
+      mujoco.mjv_applyPerturbForce(self.mjm, self.mjd, pert)
+
+      body_id = pert.select
+      force = self.mjd.xfrc_applied[body_id, :3].copy()
+      torque = self.mjd.xfrc_applied[body_id, 3:].copy()
+      point = self.mjd.xipos[body_id].copy()
+
+      # Convert to generalized forces.
+      qfrc = np.zeros(self.mjm.nv)
+      mujoco.mj_applyFT(self.mjm, self.mjd, force, torque, point, body_id, qfrc)
+
+      sim_data.qfrc_applied[self.env_idx] = torch.from_numpy(qfrc).to(
+        device=sim_data.qfrc_applied.device
+      )
+
+      # Clear so _sync_env_state_to_mjdata writes clean programmatic
+      # forces next frame.
+      self.mjd.xfrc_applied[body_id] = 0.0
+    else:
+      sim_data.qfrc_applied[self.env_idx] = 0.0
+
+  def close(self) -> None:
+    """Close viewer and cleanup."""
+    v = self.viewer
+    self.viewer = None
+    if v:
+      v.close()
+    self.log("[INFO] MuJoCo viewer closed", VerbosityLevel.INFO)
+
+  def reset_environment(self) -> None:
+    """Extend BaseViewer.reset_environment to clear reward histories."""
+    super().reset_environment()
+    self._clear_histories()
+
+  def _safe_key_callback(self, key: int) -> None:
+    """Runs on MuJoCo viewer thread; must not touch env/sim directly."""
+    from mjlab.viewer.native.keys import (
+      KEY_A,
+      KEY_COMMA,
+      KEY_ENTER,
+      KEY_EQUAL,
+      KEY_MINUS,
+      KEY_P,
+      KEY_PERIOD,
+      KEY_R,
+      KEY_RIGHT,
+      KEY_SPACE,
+    )
+
+    if key == KEY_ENTER:
+      self.request_reset()
+    elif key == KEY_SPACE:
+      self.request_toggle_pause()
+    elif key == KEY_MINUS:
+      self.request_speed_down()
+    elif key == KEY_EQUAL:
+      self.request_speed_up()
+    elif key == KEY_COMMA:
+      self.request_action("PREV_ENV")
+    elif key == KEY_PERIOD:
+      self.request_action("NEXT_ENV")
+    elif key == KEY_P:
+      self.request_action("TOGGLE_PLOTS")
+    elif key == KEY_R:
+      self.request_action("TOGGLE_DEBUG_VIS")
+    elif key == KEY_A:
+      self.request_action("TOGGLE_SHOW_ALL_ENVS")
+    elif key == KEY_RIGHT:
+      self.request_single_step()
+
+    if self.user_key_callback:
+      try:
+        self.user_key_callback(key)
+      except Exception as e:
+        self.log(f"[WARN] user key_callback raised: {e}", VerbosityLevel.INFO)
+
+  def _forward_paused(self) -> None:
+    """Run forward kinematics while paused to keep perturbation visuals accurate."""
+    if self.mjm is not None and self.mjd is not None:
+      with self._mj_lock:
+        mujoco.mj_forward(self.mjm, self.mjd)
+
+  def _handle_custom_action(self, action: ViewerAction, payload: object | None) -> bool:
+    del payload
+    if action == ViewerAction.PREV_ENV and self.env.unwrapped.num_envs > 1:
+      self.env_idx = (self.env_idx - 1) % self.env.unwrapped.num_envs
+      self._clear_histories()
+      self.log(f"[INFO] Switched to environment {self.env_idx}", VerbosityLevel.INFO)
+      return True
+    if action == ViewerAction.NEXT_ENV and self.env.unwrapped.num_envs > 1:
+      self.env_idx = (self.env_idx + 1) % self.env.unwrapped.num_envs
+      self._clear_histories()
+      self.log(f"[INFO] Switched to environment {self.env_idx}", VerbosityLevel.INFO)
+      return True
+    if action == ViewerAction.TOGGLE_PLOTS:
+      self._show_plots = not self._show_plots
+      self.log(
+        f"[INFO] Reward plots {'shown' if self._show_plots else 'hidden'}",
+        VerbosityLevel.INFO,
+      )
+      return True
+    if action == ViewerAction.TOGGLE_DEBUG_VIS:
+      self._show_debug_vis = not self._show_debug_vis
+      self.log(
+        f"[INFO] Debug visualization {'shown' if self._show_debug_vis else 'hidden'}",
+        VerbosityLevel.INFO,
+      )
+      return True
+    if action == ViewerAction.TOGGLE_SHOW_ALL_ENVS:
+      self._show_all_envs = not self._show_all_envs
+      self.log(
+        f"[INFO] Show all envs {'enabled' if self._show_all_envs else 'disabled'}",
+        VerbosityLevel.INFO,
+      )
+      return True
+    return False
+
+  def _setup_camera(self) -> None:
+    """Configure native viewer camera from viewer config."""
+    assert self.viewer is not None
+    self.viewer.opt.frame = mujoco.mjtFrame.mjFRAME_WORLD.value
+
+    if not self.cfg or not hasattr(self.cfg, "origin_type"):
+      self._set_camera_auto_track()
+      return
+
+    if self.cfg.origin_type == self.cfg.OriginType.AUTO:
+      self._set_camera_auto_track()
+    elif self.cfg.origin_type == self.cfg.OriginType.WORLD:
+      self._set_camera_world()
+    elif self.cfg.origin_type == self.cfg.OriginType.ASSET_ROOT:
+      self._set_camera_asset_root()
+    else:  # ASSET_BODY
+      self._set_camera_asset_body()
+
+    self.viewer.cam.lookat = getattr(self.cfg, "lookat", self.viewer.cam.lookat)
+    self.viewer.cam.elevation = getattr(
+      self.cfg, "elevation", self.viewer.cam.elevation
+    )
+    self.viewer.cam.azimuth = getattr(self.cfg, "azimuth", self.viewer.cam.azimuth)
+    self.viewer.cam.distance = getattr(self.cfg, "distance", self.viewer.cam.distance)
+
+  def _set_camera_auto_track(self) -> None:
+    """Track first non-fixed body; fall back to free camera if none exists."""
+    assert self.viewer is not None
+    assert self.mjm is not None
+    for body_id in range(self.mjm.nbody):
+      is_weld = self.mjm.body_weldid[body_id] == 0
+      root_id = self.mjm.body_rootid[body_id]
+      root_is_mocap = self.mjm.body_mocapid[root_id] >= 0
+      if not (is_weld and not root_is_mocap):
+        self.viewer.cam.type = mujoco.mjtCamera.mjCAMERA_TRACKING.value
+        self.viewer.cam.trackbodyid = body_id
+        self.viewer.cam.fixedcamid = -1
+        return
+    self._set_camera_world()
+
+  def _set_camera_world(self) -> None:
+    """Configure free camera in world frame."""
+    assert self.viewer is not None
+    self.viewer.cam.type = mujoco.mjtCamera.mjCAMERA_FREE.value
+    self.viewer.cam.fixedcamid = -1
+    self.viewer.cam.trackbodyid = -1
+
+  def _set_camera_asset_root(self) -> None:
+    """Track the root body of a configured asset."""
+    assert self.viewer is not None
+    if not self.cfg.entity_name:
+      raise ValueError("Asset name must be specified for ASSET_ROOT origin type")
+    robot: Entity = self.env.unwrapped.scene[self.cfg.entity_name]
+    body_id = robot.indexing.root_body_id
+    self.viewer.cam.type = mujoco.mjtCamera.mjCAMERA_TRACKING.value
+    self.viewer.cam.trackbodyid = body_id
+    self.viewer.cam.fixedcamid = -1
+
+  def _set_camera_asset_body(self) -> None:
+    """Track a specific body of a configured asset."""
+    assert self.viewer is not None
+    if not self.cfg.entity_name or not self.cfg.body_name:
+      raise ValueError("entity_name/body_name required for ASSET_BODY origin type")
+    robot: Entity = self.env.unwrapped.scene[self.cfg.entity_name]
+    if self.cfg.body_name not in robot.body_names:
+      raise ValueError(
+        f"Body '{self.cfg.body_name}' not found in asset '{self.cfg.entity_name}'"
+      )
+    body_id_list, _ = robot.find_bodies(self.cfg.body_name)
+    body_id = robot.indexing.bodies[body_id_list[0]].id
+
+    self.viewer.cam.type = mujoco.mjtCamera.mjCAMERA_TRACKING.value
+    self.viewer.cam.trackbodyid = body_id
+    self.viewer.cam.fixedcamid = -1
+
+  # Reward plotting helpers.
+
+  def _init_reward_plots(self, term_names: list[str]) -> None:
+    """Create per-term figures and histories."""
+    self._figures.clear()
+    self._histories.clear()
+    self._yrange.clear()
+    self._scale.clear()
+    for name in term_names:
+      self._figures[name] = make_empty_figure(
+        name,
+        self._plot_cfg.grid_size,
+        self._plot_cfg.init_yrange,
+        self._plot_cfg.history,
+        self._plot_cfg.background_alpha,
+      )
+      self._histories[name] = deque(maxlen=self._plot_cfg.history)
+      self._yrange[name] = self._plot_cfg.init_yrange
+      self._scale[name] = 1.0
+
+  def _clear_histories(self) -> None:
+    """Clear histories and reset figures."""
+    for name in self._term_names:
+      self._histories[name].clear()
+      self._yrange[name] = self._plot_cfg.init_yrange
+      self._scale[name] = 1.0
+      fig = self._figures[name]
+      fig.title = name
+      fig.linepnt[0] = 0
+      fig.range[1][0] = float(self._plot_cfg.init_yrange[0])
+      fig.range[1][1] = float(self._plot_cfg.init_yrange[1])
+
+  def _append_point(self, name: str, value: float) -> None:
+    """Append a new point to the ring buffer."""
+    if not np.isfinite(value):
+      return
+    self._histories[name].append(float(value))
+
+  def _write_history_to_figure(self, name: str) -> None:
+    """Copy history into figure and autoscale y-axis."""
+    fig = self._figures[name]
+    hist = self._histories[name]
+    n = min(len(hist), self._plot_cfg.history)
+
+    # Autoscale y-axis (in raw units).
+    if n >= 5:
+      data = np.fromiter(hist, dtype=float, count=n)
+      lo = float(np.percentile(data, self._plot_cfg.p_lo))
+      hi = float(np.percentile(data, self._plot_cfg.p_hi))
+      span = max(hi - lo, self._plot_cfg.min_span)
+      lo -= self._plot_cfg.pad * span
+      hi += self._plot_cfg.pad * span
+    elif n >= 1:
+      v = float(hist[-1])
+      span = max(abs(v), 1e-3)
+      lo, hi = v - span, v + span
+    else:
+      lo, hi = self._plot_cfg.init_yrange
+
+    # Compute scale factor so axis labels avoid scientific notation.
+    scale = _display_scale(lo, hi)
+    self._scale[name] = scale
+
+    # Write scaled data into figure.
+    fig.linepnt[0] = n
+    for i in range(n):
+      fig.linedata[0][2 * i] = float(-i)
+      fig.linedata[0][2 * i + 1] = float(hist[-1 - i]) * scale
+
+    fig.range[1][0] = float(lo * scale)
+    fig.range[1][1] = float(hi * scale)
+
+    # Update title with scale suffix.
+    if scale == 1.0:
+      fig.title = name
+    else:
+      exp = round(math.log10(1.0 / scale))
+      fig.title = f"{name} (1e{exp})"
+
+
+def _display_scale(lo: float, hi: float) -> float:
+  """Return a power-of-10 multiplier that brings *lo*/*hi* into a readable range.
+
+  Values in [0.01, 100] render as clean decimals in MuJoCo's ``%g``
+  tick labels, so we only rescale outside that band.
+  """
+  max_abs = max(abs(lo), abs(hi))
+  if max_abs < 1e-15:
+    return 1.0
+  exp = math.floor(math.log10(max_abs))
+  if -2 <= exp <= 2:
+    return 1.0
+  return 10.0 ** (-exp)
+
+
+def compute_viewports(
+  num_plots: int,
+  rect: mujoco.MjrRect,
+  cfg: PlotCfg,
+) -> list[mujoco.MjrRect]:
+  """Lay plots in a strip on the right."""
+  if num_plots <= 0:
+    return []
+  cols = 1 if num_plots <= cfg.max_rows_per_col else 2
+  rows = min(cfg.max_rows_per_col, (num_plots + cols - 1) // cols)
+
+  vp_w = int(rect.width * cfg.plot_strip_fraction) // 2
+  strip_w = vp_w * cols
+  vp_h = rect.height // max(rows, cfg.min_rows_per_col)
+
+  left0 = rect.left + rect.width - strip_w
+  vps: list[mujoco.MjrRect] = []
+  for idx in range(min(num_plots, cfg.max_viewports)):
+    c = idx // rows
+    r = idx % rows
+    left = left0 + (cols - 1 - c) * vp_w
+    bottom = rect.bottom + rect.height - (r + 1) * vp_h
+    vps.append(mujoco.MjrRect(left=left, bottom=bottom, width=vp_w, height=vp_h))
+  return vps
+
+
+def make_empty_figure(
+  title: str,
+  grid_size: tuple[int, int],
+  yrange: tuple[float, float],
+  history: int,
+  alpha: float,
+) -> mujoco.MjvFigure:
+  fig = mujoco.MjvFigure()
+  mujoco.mjv_defaultFigure(fig)
+  fig.flg_extend = 1
+  fig.gridsize[0] = grid_size[0]
+  fig.gridsize[1] = grid_size[1]
+  fig.range[1][0] = float(yrange[0])
+  fig.range[1][1] = float(yrange[1])
+  fig.figurergba[3] = alpha
+  fig.title = title
+  # Pre-fill x coordinates; y's will be written on update.
+  for i in range(history):
+    fig.linedata[0][2 * i] = -float(i)
+    fig.linedata[0][2 * i + 1] = 0.0
+  fig.linepnt[0] = 0
+  return fig
diff --git a/src/mjlab/viewer/native/visualizer.py b/src/mjlab/viewer/native/visualizer.py
new file mode 100644
index 0000000..22bb0c4
--- /dev/null
+++ b/src/mjlab/viewer/native/visualizer.py
@@ -0,0 +1,276 @@
+"""MuJoCo native viewer debug visualizer implementation."""
+
+from __future__ import annotations
+
+import mujoco
+import numpy as np
+from typing_extensions import override
+
+from mjlab.viewer.debug_visualizer import DebugVisualizer
+
+
+class MujocoNativeDebugVisualizer(DebugVisualizer):
+  """Debug visualizer for MuJoCo's native viewer.
+
+  This implementation directly adds geometry to the MuJoCo scene using mjv_addGeoms
+  and other MuJoCo visualization primitives.
+  """
+
+  def __init__(
+    self,
+    scn: mujoco.MjvScene,
+    mj_model: mujoco.MjModel,
+    env_idx: int,
+    show_all_envs: bool = False,
+  ):
+    """Initialize the MuJoCo native visualizer.
+
+    Args:
+      scn: MuJoCo scene to add visualizations to
+      mj_model: MuJoCo model for creating visualization data
+      env_idx: Index of the environment being visualized
+      show_all_envs: If True, visualize all environments instead of just env_idx
+    """
+    # DebugVisualizer interface.
+    self.env_idx = env_idx
+    self.show_all_envs = show_all_envs
+
+    self._mjv_scene = scn
+    self._initial_geom_count = scn.ngeom
+    self._meansize: float = mj_model.stat.meansize
+
+    # State used only by the ghost visualization. The model is a shared
+    # reference and must not be modified; ghost transparency is controlled
+    # through the mjVIS_TRANSPARENT flag rather than per-geom alpha.
+    self._ref_mj_model = mj_model
+    self._mj_data = mujoco.MjData(mj_model)
+    self._vopt = mujoco.MjvOption()
+    self._vopt.flags[mujoco.mjtVisFlag.mjVIS_TRANSPARENT] = True
+    self._pert = mujoco.MjvPerturb()
+
+  @property
+  @override
+  def meansize(self) -> float:
+    return self._meansize
+
+  @override
+  def add_arrow(
+    self,
+    start: np.ndarray,
+    end: np.ndarray,
+    color: tuple[float, float, float, float],
+    width: float = 0.015,
+    label: str | None = None,
+  ) -> None:
+    """Add an arrow visualization using MuJoCo's arrow geometry."""
+    del label  # Unused.
+
+    self._mjv_scene.ngeom += 1
+    geom = self._mjv_scene.geoms[self._mjv_scene.ngeom - 1]
+    geom.category = mujoco.mjtCatBit.mjCAT_DECOR
+
+    mujoco.mjv_initGeom(
+      geom=geom,
+      type=mujoco.mjtGeom.mjGEOM_ARROW.value,
+      size=np.zeros(3),
+      pos=np.zeros(3),
+      mat=np.zeros(9),
+      rgba=np.asarray(color, dtype=np.float32),
+    )
+    mujoco.mjv_connector(
+      geom=geom,
+      type=mujoco.mjtGeom.mjGEOM_ARROW.value,
+      width=width,
+      from_=start,
+      to=end,
+    )
+
+  @override
+  def add_ghost_mesh(
+    self,
+    qpos: np.ndarray,
+    model: mujoco.MjModel,
+    mocap_pos: np.ndarray | None = None,
+    mocap_quat: np.ndarray | None = None,
+    alpha: float = 0.5,
+    label: str | None = None,
+  ) -> None:
+    """Add a ghost mesh by rendering the robot at a different pose.
+
+    This creates a semi-transparent copy of the robot geometry at the target pose.
+
+    Args:
+      qpos: Joint positions for the ghost pose
+      model: MuJoCo model with pre-configured appearance (geom_rgba for colors).
+        Must be structurally identical to the model this visualizer was
+        created with, since it is evaluated against the internal MjData.
+      mocap_pos: Optional mocap position(s) for fixed-base entities
+      mocap_quat: Optional mocap quaternion(s) for fixed-base entities
+      alpha: Transparency override (not used in MuJoCo implementation)
+      label: Optional label (not used in MuJoCo implementation)
+    """
+    del alpha, label  # Unused.
+
+    self._mj_data.qpos[:] = qpos
+    if mocap_pos is not None and model.nmocap > 0:
+      mocap_pos_arr = np.asarray(mocap_pos)
+      if mocap_pos_arr.ndim == 1:
+        self._mj_data.mocap_pos[0] = mocap_pos_arr
+      else:
+        self._mj_data.mocap_pos[:] = mocap_pos_arr
+    if mocap_quat is not None and model.nmocap > 0:
+      mocap_quat_arr = np.asarray(mocap_quat)
+      if mocap_quat_arr.ndim == 1:
+        self._mj_data.mocap_quat[0] = mocap_quat_arr
+      else:
+        self._mj_data.mocap_quat[:] = mocap_quat_arr
+    mujoco.mj_forward(model, self._mj_data)
+
+    mujoco.mjv_addGeoms(
+      model,
+      self._mj_data,
+      self._vopt,
+      self._pert,
+      mujoco.mjtCatBit.mjCAT_DYNAMIC.value,
+      self._mjv_scene,
+    )
+
+  @override
+  def add_frame(
+    self,
+    position: np.ndarray,
+    rotation_matrix: np.ndarray,
+    scale: float = 0.3,
+    label: str | None = None,
+    axis_radius: float = 0.01,
+    alpha: float = 1.0,
+    axis_colors: tuple[tuple[float, float, float], ...] | None = None,
+  ) -> None:
+    """Add a coordinate frame visualization with RGB-colored axes."""
+    del label  # Unused.
+
+    default_colors = [(0.9, 0, 0), (0, 0.9, 0.0), (0.0, 0.0, 0.9)]
+    colors = axis_colors if axis_colors is not None else default_colors
+
+    for axis_idx in range(3):
+      axis_direction = rotation_matrix[:, axis_idx]
+      end_position = position + axis_direction * scale
+      rgb = colors[axis_idx]
+      color_rgba = (rgb[0], rgb[1], rgb[2], alpha)
+      self.add_arrow(
+        start=position,
+        end=end_position,
+        color=color_rgba,
+        width=axis_radius,
+      )
+
+  @override
+  def add_sphere(
+    self,
+    center: np.ndarray,
+    radius: float,
+    color: tuple[float, float, float, float],
+    label: str | None = None,
+  ) -> None:
+    """Add a sphere visualization using MuJoCo's sphere geometry."""
+    del label  # Unused.
+
+    self._mjv_scene.ngeom += 1
+    geom = self._mjv_scene.geoms[self._mjv_scene.ngeom - 1]
+    geom.category = mujoco.mjtCatBit.mjCAT_DECOR
+
+    mujoco.mjv_initGeom(
+      geom=geom,
+      type=mujoco.mjtGeom.mjGEOM_SPHERE.value,
+      size=np.array([radius, 0, 0]),
+      pos=center,
+      mat=np.eye(3).flatten(),
+      rgba=np.asarray(color, dtype=np.float32),
+    )
+
+  @override
+  def add_cylinder(
+    self,
+    start: np.ndarray,
+    end: np.ndarray,
+    radius: float,
+    color: tuple[float, float, float, float],
+    label: str | None = None,
+  ) -> None:
+    """Add a cylinder visualization using MuJoCo's cylinder connector."""
+    del label  # Unused.
+
+    self._mjv_scene.ngeom += 1
+    geom = self._mjv_scene.geoms[self._mjv_scene.ngeom - 1]
+    geom.category = mujoco.mjtCatBit.mjCAT_DECOR
+
+    mujoco.mjv_initGeom(
+      geom=geom,
+      type=mujoco.mjtGeom.mjGEOM_CYLINDER.value,
+      size=np.zeros(3),
+      pos=np.zeros(3),
+      mat=np.zeros(9),
+      rgba=np.asarray(color, dtype=np.float32),
+    )
+    mujoco.mjv_connector(
+      geom=geom,
+      type=mujoco.mjtGeom.mjGEOM_CYLINDER.value,
+      width=radius,
+      from_=start,
+      to=end,
+    )
+
+  @override
+  def add_ellipsoid(
+    self,
+    center: np.ndarray,
+    size: np.ndarray,
+    mat: np.ndarray,
+    color: tuple[float, float, float, float],
+    label: str | None = None,
+  ) -> None:
+    """Add an ellipsoid visualization using MuJoCo's ellipsoid geometry."""
+    del label  # Unused.
+
+    self._mjv_scene.ngeom += 1
+    geom = self._mjv_scene.geoms[self._mjv_scene.ngeom - 1]
+    geom.category = mujoco.mjtCatBit.mjCAT_DECOR
+
+    mujoco.mjv_initGeom(
+      geom=geom,
+      type=mujoco.mjtGeom.mjGEOM_ELLIPSOID.value,
+      size=np.asarray(size, dtype=np.float64),
+      pos=np.asarray(center, dtype=np.float64),
+      mat=np.asarray(mat, dtype=np.float64).flatten(),
+      rgba=np.asarray(color, dtype=np.float32),
+    )
+
+  @override
+  def add_box(
+    self,
+    center: np.ndarray,
+    size: np.ndarray,
+    mat: np.ndarray,
+    color: tuple[float, float, float, float],
+    label: str | None = None,
+  ) -> None:
+    """Add a box visualization using MuJoCo's box geometry."""
+    del label  # Unused.
+
+    self._mjv_scene.ngeom += 1
+    geom = self._mjv_scene.geoms[self._mjv_scene.ngeom - 1]
+    geom.category = mujoco.mjtCatBit.mjCAT_DECOR
+
+    mujoco.mjv_initGeom(
+      geom=geom,
+      type=mujoco.mjtGeom.mjGEOM_BOX.value,
+      size=np.asarray(size, dtype=np.float64),
+      pos=np.asarray(center, dtype=np.float64),
+      mat=np.asarray(mat, dtype=np.float64).flatten(),
+      rgba=np.asarray(color, dtype=np.float32),
+    )
+
+  @override
+  def clear(self) -> None:
+    """Clear debug visualizations by resetting geom count."""
+    self._mjv_scene.ngeom = self._initial_geom_count
diff --git a/src/mjlab/viewer/offscreen_renderer.py b/src/mjlab/viewer/offscreen_renderer.py
new file mode 100644
index 0000000..83f0921
--- /dev/null
+++ b/src/mjlab/viewer/offscreen_renderer.py
@@ -0,0 +1,255 @@
+"""MuJoCo offscreen renderer for headless visualization."""
+
+import copy
+from typing import Any, Callable
+
+import mujoco
+import numpy as np
+
+from mjlab.entity import Entity
+from mjlab.scene import Scene
+from mjlab.viewer.model_sync import (
+  VIEWER_MODEL_FIELDS,
+  disable_model_sameframe_shortcuts,
+  sync_model_fields,
+)
+from mjlab.viewer.native.visualizer import MujocoNativeDebugVisualizer
+from mjlab.viewer.viewer_config import ViewerConfig
+
+
+def _get_camera_body_id(cfg: ViewerConfig, entities: dict[str, Entity]) -> int:
+  """Resolve the body id the camera tracks, or -1 for free cameras."""
+  if cfg.origin_type in (
+    ViewerConfig.OriginType.AUTO,
+    ViewerConfig.OriginType.WORLD,
+  ):
+    return -1
+
+  entity_name = cfg.entity_name
+  if entity_name is None:
+    if len(entities) != 1:
+      raise ValueError(
+        f"Cannot auto-detect entity: scene has {len(entities)} entities "
+        f"({list(entities.keys())}). Set ViewerConfig.entity_name to choose one."
+      )
+    entity_name = next(iter(entities))
+  elif entity_name not in entities:
+    raise ValueError(
+      f"Entity '{entity_name}' not found in scene. "
+      f"Available entities: {list(entities.keys())}."
+    )
+  entity = entities[entity_name]
+
+  if cfg.origin_type == ViewerConfig.OriginType.ASSET_ROOT:
+    return entity.indexing.root_body_id
+
+  assert cfg.origin_type == ViewerConfig.OriginType.ASSET_BODY
+  if not cfg.body_name:
+    raise ValueError("body_name is required for the ASSET_BODY origin type.")
+  if cfg.body_name not in entity.body_names:
+    raise ValueError(f"Body '{cfg.body_name}' not found in entity '{entity_name}'.")
+  body_ids, _ = entity.find_bodies(cfg.body_name)
+  return entity.indexing.bodies[body_ids[0]].id
+
+
+class OffscreenRenderer:
+  def __init__(
+    self,
+    model: mujoco.MjModel,
+    cfg: ViewerConfig,
+    scene: Scene,
+    sim_model: Any | None = None,
+    expanded_fields: set[str] | None = None,
+  ) -> None:
+    self._cfg = cfg
+    self._scene = scene
+    self._sim_model = sim_model
+    self._expanded_fields = expanded_fields
+
+    # Work on a copy so render-only tweaks (extent, shadows, reflections,
+    # sameframe shortcuts) never leak into the shared model.
+    self._model = copy.copy(model)
+    self._data = mujoco.MjData(self._model)
+
+    if self._sim_model is not None:
+      disable_model_sameframe_shortcuts(self._model)
+
+    # Keep extent override local to offscreen rendering so shadow/camera scaling
+    # is not dominated by the full multi-env world bounds.
+    self._model.stat.extent = self._compute_render_extent(cfg.distance)
+
+    self._model.vis.global_.offheight = cfg.height
+    self._model.vis.global_.offwidth = cfg.width
+    if cfg.fovy is not None:
+      self._model.vis.global_.fovy = cfg.fovy
+
+    if not cfg.enable_shadows:
+      self._model.light_castshadow[:] = False
+    if not cfg.enable_reflections:
+      self._model.mat_reflectance[:] = 0.0
+
+    self._cam = self._setup_camera(cfg, self._model, scene.entities)
+    self._env_ids: tuple[int, ...] | None = None
+
+    self._renderer: mujoco.Renderer | None = None
+    self._opt = mujoco.MjvOption()
+    self._opt.geomgroup[:] = np.array(cfg.geom_group, dtype=np.uint8)
+    self._opt.sitegroup[:] = np.array(cfg.site_group, dtype=np.uint8)
+    self._pert = mujoco.MjvPerturb()
+    self._catmask = mujoco.mjtCatBit.mjCAT_DYNAMIC
+
+  @property
+  def renderer(self) -> mujoco.Renderer:
+    if self._renderer is None:
+      raise ValueError("Renderer not initialized. Call 'initialize()' first.")
+
+    return self._renderer
+
+  def initialize(self) -> None:
+    if self._renderer is not None:
+      raise RuntimeError(
+        "Renderer is already initialized. Call 'close()' first to reinitialize."
+      )
+    self._renderer = mujoco.Renderer(
+      model=self._model, height=self._cfg.height, width=self._cfg.width
+    )
+
+  def update(
+    self,
+    data: Any,
+    debug_vis_callback: Callable[[MujocoNativeDebugVisualizer], None] | None = None,
+    camera: str | None = None,
+  ) -> None:
+    """Update renderer with simulation data."""
+    if self._renderer is None:
+      raise ValueError("Renderer not initialized. Call 'initialize()' first.")
+
+    if int(data.nworld) <= 0:
+      return
+
+    if self._env_ids is None:
+      self._env_ids = self._get_env_ids(
+        self._cfg, self._scene.env_origins.cpu().numpy()
+      )
+
+    # The primary env frames the camera and receives the debug overlays.
+    primary_env = self._env_ids[0]
+    self._sync_model_fields(primary_env)
+    self._sync_data_fields(data, primary_env)
+
+    cam = camera if camera is not None else self._cam
+    self._renderer.update_scene(self._data, camera=cam, scene_option=self._opt)
+
+    # Note: update_scene() resets the scene each frame, so no need to manually clear.
+    if debug_vis_callback is not None:
+      visualizer = MujocoNativeDebugVisualizer(
+        self._renderer.scene, self._model, env_idx=primary_env
+      )
+      debug_vis_callback(visualizer)
+
+    # Add neighboring environments as geoms for context.
+    for env_id in self._env_ids[1:]:
+      self._sync_model_fields(env_id)
+      self._sync_data_fields(data, env_id)
+      mujoco.mjv_addGeoms(
+        self._model,
+        self._data,
+        self._opt,
+        self._pert,
+        self._catmask.value,
+        self._renderer.scene,
+      )
+
+  def render(self) -> np.ndarray:
+    if self._renderer is None:
+      raise ValueError("Renderer not initialized. Call 'initialize()' first.")
+
+    return self._renderer.render()
+
+  def close(self) -> None:
+    if self._renderer is not None:
+      self._renderer.close()
+      self._renderer = None
+
+  def _sync_data_fields(self, data: Any, env_idx: int) -> None:
+    """Copy one env's state into the host MjData and refresh kinematics."""
+    if self._model.nq > 0:
+      self._data.qpos[:] = data.qpos[env_idx].cpu().numpy()
+      self._data.qvel[:] = data.qvel[env_idx].cpu().numpy()
+    if self._model.nmocap > 0:
+      self._data.mocap_pos[:] = data.mocap_pos[env_idx].cpu().numpy()
+      self._data.mocap_quat[:] = data.mocap_quat[env_idx].cpu().numpy()
+    mujoco.mj_forward(self._model, self._data)
+
+  def _sync_model_fields(self, env_idx: int) -> None:
+    """Sync visually relevant per-world model fields into the host MjModel."""
+    if self._sim_model is None or self._expanded_fields is None:
+      return
+    fields = self._expanded_fields & VIEWER_MODEL_FIELDS
+    sync_model_fields(self._model, self._sim_model, fields, env_idx)
+
+  @staticmethod
+  def _get_env_ids(cfg: ViewerConfig, env_origins: np.ndarray) -> tuple[int, ...]:
+    """Return the ids of the environments to render, primary env first.
+
+    The primary env is cfg.env_idx (clamped to the available worlds), followed
+    by up to max_extra_envs nearest neighbors by env origin, so videos stay
+    focused on the tracked robot and nearby peers.
+
+    The set is resolved once, on first use, and kept stable: env_origins can
+    mutate during training (e.g. the terrain curriculum reassigns origins on
+    reset), and recomputing every frame would make the context robots pop in
+    and out, causing video flicker.
+    """
+    if cfg.max_extra_envs < 0:
+      raise ValueError(
+        f"'max_extra_envs' must be non-negative, got {cfg.max_extra_envs}."
+      )
+
+    n_world = env_origins.shape[0]
+    env_idx = max(0, min(int(cfg.env_idx), n_world - 1))
+    k = min(cfg.max_extra_envs, n_world - 1)
+    if k <= 0:
+      return (env_idx,)
+
+    dist2 = np.sum((env_origins - env_origins[env_idx]) ** 2, axis=1)
+    dist2[env_idx] = np.inf
+    nearest = np.argpartition(dist2, kth=k - 1)[:k]
+    nearest = nearest[np.argsort(dist2[nearest])]
+    return (env_idx, *(int(i) for i in nearest))
+
+  @staticmethod
+  def _setup_camera(
+    cfg: ViewerConfig,
+    model: mujoco.MjModel,
+    entities: dict[str, Entity],
+  ) -> mujoco.MjvCamera:
+    """Setup camera based on config's origin_type."""
+    body_id = _get_camera_body_id(cfg, entities)
+
+    camera = mujoco.MjvCamera()
+    mujoco.mjv_defaultFreeCamera(model, camera)
+    if body_id == -1:
+      camera.type = mujoco.mjtCamera.mjCAMERA_FREE.value
+    else:
+      camera.type = mujoco.mjtCamera.mjCAMERA_TRACKING.value
+    camera.trackbodyid = body_id
+    camera.fixedcamid = -1
+    camera.lookat[:] = cfg.lookat
+    camera.elevation = cfg.elevation
+    camera.azimuth = cfg.azimuth
+    camera.distance = cfg.distance
+
+    return camera
+
+  @staticmethod
+  def _compute_render_extent(distance: float) -> float:
+    """Compute a stable extent for offscreen rendering.
+
+    MuJoCo scales z-near/z-far and shadow clip with ``model.stat.extent``. In
+    large scenes this auto extent can become very large, which causes
+    shadow-map precision artifacts in offscreen video rendering. We therefore
+    use a local extent tied to the camera distance, keeping enough room for
+    the tracked subject and camera motion.
+    """
+    return max(4.0, 1.5 * float(distance))
diff --git a/src/mjlab/viewer/viewer_config.py b/src/mjlab/viewer/viewer_config.py
new file mode 100644
index 0000000..3638e69
--- /dev/null
+++ b/src/mjlab/viewer/viewer_config.py
@@ -0,0 +1,65 @@
+import enum
+from dataclasses import dataclass
+
+
+@dataclass(kw_only=True)
+class ViewerConfig:
+  class OriginType(enum.Enum):
+    """The frame in which the camera position and target are defined."""
+
+    AUTO = enum.auto()
+    """Track the first non-fixed body, or fall back to a free camera."""
+    WORLD = enum.auto()
+    """Free camera at the configured lookat point."""
+    ASSET_ROOT = enum.auto()
+    """Track the root body of the asset defined by entity_name."""
+    ASSET_BODY = enum.auto()
+    """Track the body defined by body_name in the asset defined by
+    entity_name."""
+
+  # Options that apply to every origin type.
+  origin_type: OriginType = OriginType.AUTO
+
+  height: int = 240
+  width: int = 320
+
+  enable_reflections: bool = True
+  enable_shadows: bool = True
+
+  geom_group: tuple[int, int, int, int, int, int] = (1, 1, 1, 0, 0, 0)
+  """Which geom visualization groups the offscreen renderer draws."""
+
+  site_group: tuple[int, int, int, int, int, int] = (1, 1, 1, 0, 0, 0)
+  """Which site visualization groups the offscreen renderer draws."""
+
+  env_idx: int = 0
+  """Environment rendered as the primary env and tracked by the camera."""
+
+  max_extra_envs: int = 2
+  """Number of neighboring environments to render around env_idx."""
+
+  reward_bar_max_terms: int = 20
+  """Maximum number of reward terms shown in the Viser reward bar panel.
+
+  Terms beyond this limit are dropped (with a warning). Raise it for
+  environments with many reward terms."""
+
+  # Camera placement.
+  distance: float = 5.0
+  elevation: float = -45.0
+  azimuth: float = 90.0
+
+  fovy: float | None = None
+  """Vertical field of view in degrees. None keeps the model default."""
+
+  lookat: tuple[float, float, float] = (0.0, 0.0, 0.0)
+  """Look-at target in the world frame. Only used by the AUTO and WORLD free
+  cameras; the ASSET_ROOT and ASSET_BODY tracking cameras ignore it."""
+
+  # Fields specific to the ASSET_ROOT and ASSET_BODY tracking cameras.
+  entity_name: str | None = None
+  """Entity tracked by the camera. Auto-detected if the scene has exactly one
+  entity."""
+
+  body_name: str | None = None
+  """Body tracked by the camera. Required for ASSET_BODY."""
diff --git a/src/mjlab/viewer/viser/__init__.py b/src/mjlab/viewer/viser/__init__.py
new file mode 100644
index 0000000..57b002f
--- /dev/null
+++ b/src/mjlab/viewer/viser/__init__.py
@@ -0,0 +1,25 @@
+"""Viser web-based viewer implementation."""
+
+from mjviser.conversions import create_primitive_mesh as create_primitive_mesh
+from mjviser.conversions import create_site_mesh as create_site_mesh
+from mjviser.conversions import get_body_name as get_body_name
+from mjviser.conversions import get_geom_texture_id as get_geom_texture_id
+from mjviser.conversions import get_site_name as get_site_name
+from mjviser.conversions import (
+  group_geoms_by_visual_compat as group_geoms_by_visual_compat,
+)
+from mjviser.conversions import is_fixed_body as is_fixed_body
+from mjviser.conversions import merge_geoms as merge_geoms
+from mjviser.conversions import merge_sites as merge_sites
+from mjviser.conversions import mujoco_mesh_to_trimesh as mujoco_mesh_to_trimesh
+from mjviser.conversions import (
+  rotation_matrix_from_vectors as rotation_matrix_from_vectors,
+)
+
+from mjlab.viewer.viser.reward_bar_panel import RewardBarPanel as RewardBarPanel
+from mjlab.viewer.viser.scene import MjlabViserScene as MjlabViserScene
+from mjlab.viewer.viser.term_plotter import ViserTermPlotter as ViserTermPlotter
+from mjlab.viewer.viser.viewer import ViserPlayViewer as ViserPlayViewer
+
+# Backwards compatibility alias.
+ViserMujocoScene = MjlabViserScene
diff --git a/src/mjlab/viewer/viser/camera_viewer.py b/src/mjlab/viewer/viser/camera_viewer.py
new file mode 100644
index 0000000..320d971
--- /dev/null
+++ b/src/mjlab/viewer/viser/camera_viewer.py
@@ -0,0 +1,191 @@
+"""Camera image visualization for Viser viewer."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import mujoco
+import numpy as np
+import viser
+import viser.transforms as vtf
+
+if TYPE_CHECKING:
+  from mjlab.sensor.camera_sensor import CameraSensor
+
+
+def _colorize_segmentation(seg: np.ndarray) -> np.ndarray:
+  """Map typed segmentation pairs to distinct RGB colors."""
+  h, w, _ = seg.shape
+  rgb = np.zeros((h, w, 3), dtype=np.uint8)
+  obj_ids = seg[..., 0]
+  obj_types = seg[..., 1]
+  mask = (obj_ids >= 0) & (obj_types >= 0)
+  if mask.any():
+    ids = obj_ids[mask].astype(np.uint32)
+    types = obj_types[mask].astype(np.uint32)
+    keys = ids * np.uint32(1315423911) ^ types * np.uint32(2654435761)
+    rgb[mask, 0] = ((keys * 67 + 29) % 255 + 1).astype(np.uint8)
+    rgb[mask, 1] = ((keys * 131 + 53) % 255 + 1).astype(np.uint8)
+    rgb[mask, 2] = ((keys * 199 + 97) % 255 + 1).astype(np.uint8)
+  return rgb
+
+
+class ViserCameraViewer:
+  """Handles camera image visualization for the Viser viewer."""
+
+  def __init__(
+    self,
+    server: viser.ViserServer,
+    camera_sensor: CameraSensor,
+    mj_model: mujoco.MjModel,
+    min_display_size: int = 128,
+  ):
+    self._server = server
+    self._camera_sensor = camera_sensor
+    self._mj_model = mj_model
+
+    self._rgb_handle: viser.GuiImageHandle | None = None
+    self._depth_handle: viser.GuiImageHandle | None = None
+    self._seg_handle: viser.GuiImageHandle | None = None
+    self._frustum_handle: viser.CameraFrustumHandle | None = None
+
+    self._camera_name = camera_sensor.camera_name
+    self._camera_idx = camera_sensor.camera_idx
+
+    self._has_rgb = "rgb" in self._camera_sensor.cfg.data_types
+    self._has_depth = "depth" in self._camera_sensor.cfg.data_types
+    self._has_seg = "segmentation" in self._camera_sensor.cfg.data_types
+
+    height = self._camera_sensor.cfg.height
+    width = self._camera_sensor.cfg.width
+
+    scale = max(1, min_display_size // max(height, width))
+    self._display_height = height * scale
+    self._display_width = width * scale
+    self._needs_upsampling = scale > 1
+
+    if self._has_rgb:
+      self._rgb_handle = self._server.gui.add_image(
+        image=np.zeros((self._display_height, self._display_width, 3), dtype=np.uint8),
+        label=f"{self._camera_name}_rgb",
+        format="jpeg",
+      )
+
+    if self._has_depth:
+      self._depth_scale_slider = self._server.gui.add_slider(
+        label="Depth Scale",
+        min=0.1,
+        max=10.0,
+        step=0.1,
+        initial_value=1.0,
+      )
+      self._depth_handle = self._server.gui.add_image(
+        image=np.zeros((self._display_height, self._display_width, 3), dtype=np.uint8),
+        label=f"{self._camera_name}_depth",
+        format="jpeg",
+      )
+
+    if self._has_seg:
+      self._seg_handle = self._server.gui.add_image(
+        image=np.zeros(
+          (self._display_height, self._display_width, 3),
+          dtype=np.uint8,
+        ),
+        label=f"{self._camera_name}_segmentation",
+        format="jpeg",
+      )
+
+    self._show_frustum_toggle = self._server.gui.add_checkbox(
+      label="Frustum",
+      initial_value=True,
+    )
+    self._fov, self._aspect = self._compute_camera_fov_aspect()
+
+  def _compute_camera_fov_aspect(self) -> tuple[float, float]:
+    cam_id = self._camera_idx
+    fovy = self._mj_model.cam_fovy[cam_id]  # in degrees
+    fovy_rad = np.deg2rad(fovy)
+    aspect = self._camera_sensor.cfg.width / self._camera_sensor.cfg.height
+    return fovy_rad, aspect
+
+  def _update_frustum(self, sim_data, env_idx: int, scene_offset: np.ndarray) -> None:
+    if not self._show_frustum_toggle.value:
+      if self._frustum_handle is not None:
+        self._frustum_handle.remove()
+        self._frustum_handle = None
+      return
+
+    # Get camera pose from simulation data
+    cam_id = self._camera_idx
+    cam_pos = sim_data.cam_xpos[env_idx, cam_id].cpu().numpy() + scene_offset
+    cam_mat = sim_data.cam_xmat[env_idx, cam_id].cpu().numpy().reshape(3, 3)  # [3, 3]
+
+    # Convert rotation matrix to quaternion (wxyz format for viser)
+    # MuJoCo camera looks along -Z axis, viser frustum expects looking along +Z
+    # So we need to rotate 180 degrees around X axis
+    rot_180_x = np.array([[1, 0, 0], [0, -1, 0], [0, 0, -1]])
+    cam_mat_adjusted = cam_mat @ rot_180_x
+
+    wxyz = vtf.SO3.from_matrix(cam_mat_adjusted).wxyz
+
+    if self._frustum_handle is None:
+      self._frustum_handle = self._server.scene.add_camera_frustum(
+        name=f"/{self._camera_name}_frustum",
+        fov=self._fov,
+        aspect=self._aspect,
+        position=cam_pos,
+        wxyz=wxyz,
+        scale=0.15,
+        color=(200, 200, 200),
+      )
+    else:
+      self._frustum_handle.position = cam_pos
+      self._frustum_handle.wxyz = wxyz
+
+  def _upsample_nearest(self, image: np.ndarray, scale: int) -> np.ndarray:
+    return np.repeat(np.repeat(image, scale, axis=0), scale, axis=1)
+
+  def _maybe_upsample(self, image: np.ndarray) -> np.ndarray:
+    if self._needs_upsampling:
+      scale = self._display_height // image.shape[0]
+      return self._upsample_nearest(image, scale)
+    return image
+
+  def update(
+    self, sim_data, env_idx: int = 0, scene_offset: np.ndarray | None = None
+  ) -> None:
+    data = self._camera_sensor.data
+
+    if self._has_rgb and self._rgb_handle is not None and data.rgb is not None:
+      rgb_np = data.rgb[env_idx].cpu().numpy()
+      self._rgb_handle.image = self._maybe_upsample(rgb_np)
+
+    if self._has_depth and self._depth_handle is not None and data.depth is not None:
+      depth_np = data.depth[env_idx].squeeze().cpu().numpy()
+      depth_scale = max(self._depth_scale_slider.value, 0.01)
+      depth_normalized = np.clip(depth_np / depth_scale, 0.0, 1.0)
+      depth_uint8 = (depth_normalized * 255).astype(np.uint8)
+      self._depth_handle.image = self._maybe_upsample(
+        np.repeat(depth_uint8[:, :, np.newaxis], 3, axis=-1)
+      )
+
+    if self._has_seg and self._seg_handle is not None and data.segmentation is not None:
+      seg_np = data.segmentation[env_idx].cpu().numpy()
+      seg_rgb = _colorize_segmentation(seg_np)
+      self._seg_handle.image = self._maybe_upsample(seg_rgb)
+
+    if scene_offset is None:
+      scene_offset = np.zeros(3)
+    self._update_frustum(sim_data, env_idx, scene_offset)
+
+  def cleanup(self) -> None:
+    if self._rgb_handle is not None:
+      self._rgb_handle.remove()
+    if self._depth_handle is not None:
+      self._depth_handle.remove()
+      self._depth_scale_slider.remove()
+    if self._seg_handle is not None:
+      self._seg_handle.remove()
+    if self._frustum_handle is not None:
+      self._frustum_handle.remove()
+    self._show_frustum_toggle.remove()
diff --git a/src/mjlab/viewer/viser/overlays.py b/src/mjlab/viewer/viser/overlays.py
new file mode 100644
index 0000000..db2d95d
--- /dev/null
+++ b/src/mjlab/viewer/viser/overlays.py
@@ -0,0 +1,217 @@
+"""Overlay managers for Viser viewer orchestration.
+
+These managers intentionally coordinate *when* higher-level updates happen
+(env switches, paused/running updates, etc.) while leaving low-level render
+handle lifecycle ownership inside :mod:`scene.py`.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+import mujoco
+import viser
+
+from mjlab.sensor import CameraSensor
+from mjlab.viewer.viser.camera_viewer import ViserCameraViewer
+from mjlab.viewer.viser.reward_bar_panel import RewardBarPanel
+from mjlab.viewer.viser.term_plotter import ViserTermPlotter
+
+
+class _EnvProtocol(Protocol):
+  @property
+  def unwrapped(self) -> Any: ...
+
+
+class _SceneProtocol(Protocol):
+  env_idx: int
+  debug_visualization_enabled: bool
+  needs_update: bool
+
+  @property
+  def show_contact_points(self) -> bool: ...
+  @property
+  def show_contact_forces(self) -> bool: ...
+
+  def clear_debug_all(self) -> None: ...
+  def clear(self) -> None: ...
+
+
+@dataclass
+class ViserTermOverlays:
+  """Manage reward/metrics term plot tabs for Viser viewer."""
+
+  server: viser.ViserServer
+  env: _EnvProtocol
+  scene: _SceneProtocol
+  frame_time: float
+  reward_bar_max_terms: int = 20
+  reward_plotter: ViserTermPlotter | None = None
+  reward_bar_panel: RewardBarPanel | None = None
+  metrics_plotter: ViserTermPlotter | None = None
+
+  def setup_tabs(self, tabs: Any) -> None:
+    """Create rewards/metrics tabs based on available managers."""
+    if hasattr(self.env.unwrapped, "reward_manager"):
+      with tabs.add_tab("Rewards", icon=viser.Icon.CHART_LINE):
+        term_names = [
+          name
+          for name, _ in self.env.unwrapped.reward_manager.get_active_iterable_terms(
+            self.scene.env_idx
+          )
+        ]
+        # Live bar panel (running-mean comparison).
+        self.reward_bar_panel = RewardBarPanel(
+          self.server,
+          term_names,
+          update_dt=self.frame_time,
+          max_terms=self.reward_bar_max_terms,
+        )
+        self.reward_plotter = ViserTermPlotter(
+          self.server, term_names, name="Reward", env_idx=self.scene.env_idx
+        )
+
+    if hasattr(self.env.unwrapped, "metrics_manager"):
+      term_names = [
+        name
+        for name, _ in self.env.unwrapped.metrics_manager.get_active_iterable_terms(
+          self.scene.env_idx
+        )
+      ]
+      if term_names:
+        with tabs.add_tab("Metrics", icon=viser.Icon.CHART_BAR):
+          self.metrics_plotter = ViserTermPlotter(
+            self.server, term_names, name="Metric", env_idx=self.scene.env_idx
+          )
+
+  def on_env_switch(self) -> None:
+    """Clear histories when active environment changes."""
+    env_idx = self.scene.env_idx
+    if self.reward_plotter:
+      self.reward_plotter.clear_histories()
+      self.reward_plotter.update_env_idx(env_idx)
+    if self.reward_bar_panel:
+      self.reward_bar_panel.clear_histories()
+    if self.metrics_plotter:
+      self.metrics_plotter.clear_histories()
+      self.metrics_plotter.update_env_idx(env_idx)
+
+  def update(self, paused: bool) -> None:
+    """Update term plots from the selected environment."""
+    if (
+      self.reward_plotter is not None or self.reward_bar_panel is not None
+    ) and not paused:
+      terms = list(
+        self.env.unwrapped.reward_manager.get_active_iterable_terms(self.scene.env_idx)
+      )
+      if self.reward_plotter is not None:
+        self.reward_plotter.update(terms)
+      if self.reward_bar_panel is not None:
+        self.reward_bar_panel.update(terms)
+
+    if self.metrics_plotter is not None and not paused:
+      terms = list(
+        self.env.unwrapped.metrics_manager.get_active_iterable_terms(self.scene.env_idx)
+      )
+      self.metrics_plotter.update(terms)
+
+  def clear_histories(self) -> None:
+    """Clear all overlay histories."""
+    self.on_env_switch()
+
+  def cleanup(self) -> None:
+    """Cleanup plotter resources."""
+    if self.reward_plotter:
+      self.reward_plotter.cleanup()
+    if self.reward_bar_panel:
+      self.reward_bar_panel.cleanup()
+    if self.metrics_plotter:
+      self.metrics_plotter.cleanup()
+
+
+@dataclass
+class ViserCameraOverlays:
+  """Manage camera feed widgets and updates for Viser viewer."""
+
+  server: viser.ViserServer
+  env: _EnvProtocol
+  mj_model: mujoco.MjModel
+  camera_viewers: list[ViserCameraViewer] | None = None
+
+  @property
+  def has_cameras(self) -> bool:
+    """Whether the environment has any camera sensors."""
+    return any(
+      isinstance(s, CameraSensor) for s in self.env.unwrapped.scene.sensors.values()
+    )
+
+  def setup_controls(self) -> None:
+    """Create camera feed controls under the active GUI folder."""
+    camera_sensors = [
+      sensor
+      for sensor in self.env.unwrapped.scene.sensors.values()
+      if isinstance(sensor, CameraSensor)
+    ]
+    if not camera_sensors:
+      self.camera_viewers = []
+      return
+
+    self.camera_viewers = [
+      ViserCameraViewer(self.server, sensor, self.mj_model) for sensor in camera_sensors
+    ]
+
+  def update(self, sim_data: Any, env_idx: int, scene_offset: Any) -> None:
+    """Push latest camera images/frustums to GUI."""
+    if not self.camera_viewers:
+      return
+    for camera_viewer in self.camera_viewers:
+      camera_viewer.update(sim_data, env_idx, scene_offset)
+
+  def cleanup(self) -> None:
+    """Cleanup all camera feed widgets."""
+    if not self.camera_viewers:
+      return
+    for camera_viewer in self.camera_viewers:
+      camera_viewer.cleanup()
+
+
+@dataclass
+class ViserDebugOverlays:
+  """Manage debug visualization queueing and env-switch behavior."""
+
+  env: _EnvProtocol
+  scene: _SceneProtocol
+
+  def on_env_switch(self) -> None:
+    """Reset debug visuals when switching selected environment."""
+    if self.scene.debug_visualization_enabled:
+      self.scene.clear_debug_all()
+
+  def queue(self) -> None:
+    """Queue environment debug visualizers for the current frame."""
+    if self.scene.debug_visualization_enabled and hasattr(
+      self.env.unwrapped, "update_visualizers"
+    ):
+      self.scene.clear()  # Clear queued arrows from previous frame.
+      self.env.unwrapped.update_visualizers(self.scene)
+
+
+@dataclass
+class ViserContactOverlays:
+  """Manage contact-visualization orchestration from the viewer layer.
+
+  Note: contact mesh creation/update/removal stays in ``ViserMujocoScene``.
+  This manager only requests scene refreshes at the right times.
+  """
+
+  scene: _SceneProtocol
+
+  def is_enabled(self) -> bool:
+    """Whether any contact visualization is currently enabled."""
+    return self.scene.show_contact_points or self.scene.show_contact_forces
+
+  def on_env_switch(self) -> None:
+    """Request a scene refresh when switching environments with contacts enabled."""
+    if self.is_enabled():
+      self.scene.needs_update = True
diff --git a/src/mjlab/viewer/viser/reward_bar_panel.py b/src/mjlab/viewer/viser/reward_bar_panel.py
new file mode 100644
index 0000000..7a107a4
--- /dev/null
+++ b/src/mjlab/viewer/viser/reward_bar_panel.py
@@ -0,0 +1,145 @@
+"""Real-time reward bar panel for the Viser viewer.
+
+Renders horizontal bars for each reward term, sized by a running mean
+over ~1 second. Positive terms are green, negative terms are red.
+"""
+
+from __future__ import annotations
+
+import html
+import warnings
+from collections import deque
+
+import numpy as np
+import viser
+
+
+class RewardBarPanel:
+  """HTML bar panel showing running-mean reward terms for quick comparison."""
+
+  def __init__(
+    self,
+    server: viser.ViserServer,
+    term_names: list[str],
+    update_dt: float,
+    max_terms: int = 20,
+  ) -> None:
+    """Initialize the reward bar panel.
+
+    Args:
+      server: The Viser server instance.
+      term_names: List of reward term names.
+      update_dt: Time in seconds between consecutive ``update()`` calls
+        (i.e. the viewer's frame time). Used to size the averaging
+        window to ~1 second.
+      max_terms: Maximum number of terms to display. Terms beyond this
+        limit are dropped (with a warning) to keep the panel readable.
+    """
+    self._server = server
+    if len(term_names) > max_terms:
+      dropped = term_names[max_terms:]
+      warnings.warn(
+        f"RewardBarPanel: {len(term_names)} reward terms exceed max_terms="
+        f"{max_terms}; the bar panel will only show the first {max_terms}. "
+        f"Hidden terms: {dropped}. Pass a larger max_terms to show them all.",
+        UserWarning,
+        stacklevel=2,
+      )
+    self._term_names = term_names[:max_terms]
+
+    # ~1 second averaging window, but at least 1 step.
+    self._window_steps = max(1, round(1.0 / update_dt))
+
+    # Per-term circular buffer for running mean.
+    self._histories: dict[str, deque[float]] = {
+      name: deque(maxlen=self._window_steps) for name in self._term_names
+    }
+
+    self._html_handle = self._server.gui.add_html("")
+    self._render_empty()
+
+  # ── public API ──────────────────────────────────────────────────
+
+  def update(self, terms: list[tuple[str, np.ndarray]]) -> None:
+    """Push new values and re-render the bars.
+
+    Args:
+      terms: List of ``(term_name, value_array)`` tuples.
+    """
+    for name, arr in terms:
+      if name not in self._histories:
+        continue
+      val = float(arr[0])
+      if np.isfinite(val):
+        self._histories[name].append(val)
+
+    self._render()
+
+  def clear_histories(self) -> None:
+    """Clear all running-mean buffers and reset display."""
+    for h in self._histories.values():
+      h.clear()
+    self._render_empty()
+
+  def cleanup(self) -> None:
+    """Remove the HTML element from the GUI."""
+    self._html_handle.remove()
+
+  # ── internal rendering ─────────────────────────────────────────
+
+  def _render_empty(self) -> None:
+    self._html_handle.content = (
+      '<div style="padding:0.5em;color:#999;font-size:0.85em;">Waiting for data…</div>'
+    )
+
+  def _render(self) -> None:
+    means: dict[str, float] = {}
+    for name in self._term_names:
+      buf = self._histories[name]
+      if buf:
+        means[name] = sum(buf) / len(buf)
+      else:
+        means[name] = 0.0
+
+    max_abs = max((abs(v) for v in means.values()), default=1e-8)
+    if max_abs < 1e-12:
+      max_abs = 1e-12
+
+    rows: list[str] = []
+    for name in self._term_names:
+      val = means[name]
+      pct = abs(val) / max_abs * 100.0
+      color = "#4caf50" if val >= 0 else "#f44336"  # green / red
+      text_color = "#fff" if pct > 25 else "#ccc"
+
+      # Value label — short scientific if tiny, else 4-decimal.
+      if abs(val) < 1e-6 and val != 0:
+        val_str = f"{val:.2e}"
+      else:
+        val_str = f"{val:.4f}"
+
+      safe_name = html.escape(name, quote=True)
+      rows.append(
+        f'<div style="display:flex;align-items:center;margin:2px 0;">'
+        # Label
+        f'<span style="min-width:120px;font-size:0.78em;text-align:right;'
+        f"padding-right:6px;color:#ddd;white-space:nowrap;overflow:hidden;"
+        f'text-overflow:ellipsis;" title="{safe_name}">{safe_name}</span>'
+        # Bar container
+        f'<div style="flex:1;background:#333;border-radius:3px;height:18px;'
+        f'position:relative;overflow:hidden;">'
+        # Bar fill
+        f'<div style="width:{pct:.1f}%;height:100%;background:{color};'
+        f'border-radius:3px;transition:width 0.15s;"></div>'
+        # Numeric value overlay
+        f'<span style="position:absolute;right:4px;top:0;line-height:18px;'
+        f'font-size:0.72em;color:{text_color};">{val_str}</span>'
+        f"</div></div>"
+      )
+
+    markup = (
+      '<div style="padding:0.3em 0.5em;font-family:monospace;">'
+      + "".join(rows)
+      + "</div>"
+    )
+    self._html_handle.content = markup
diff --git a/src/mjlab/viewer/viser/scene.py b/src/mjlab/viewer/viser/scene.py
new file mode 100644
index 0000000..91ffd74
--- /dev/null
+++ b/src/mjlab/viewer/viser/scene.py
@@ -0,0 +1,1311 @@
+"""Bridge between mjviser's ViserMujocoScene and mjlab's DebugVisualizer."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any, cast
+
+import mujoco
+import numpy as np
+import torch
+import trimesh
+import viser
+import viser.transforms as vtf
+from mjviser import ViserMujocoScene
+from mjviser.conversions import (
+  create_primitive_mesh,
+  get_body_name,
+  group_geoms_by_visual_compat,
+  is_fixed_body,
+  merge_geoms,
+  mujoco_mesh_to_trimesh,
+)
+from mujoco import mjtGeom
+from typing_extensions import override
+
+from mjlab.viewer.debug_visualizer import DebugVisualizer
+from mjlab.viewer.model_sync import (
+  VIEWER_MODEL_FIELDS,
+  disable_model_sameframe_shortcuts,
+  sync_model_fields,
+)
+
+_Z_AXIS = np.array([0.0, 0.0, 1.0])
+_IDENTITY_QUAT = np.array([1.0, 0.0, 0.0, 0.0])
+_VISER_GEOMETRY_HANDLE_FIELDS = frozenset(
+  {
+    "geom_dataid",
+    "geom_size",
+    "geom_pos",
+    "geom_quat",
+  }
+)
+_VISER_APPEARANCE_HANDLE_FIELDS = frozenset(
+  {
+    "geom_rgba",
+    "mat_rgba",
+  }
+)
+_VISER_BAKED_HANDLE_FIELDS = (
+  _VISER_GEOMETRY_HANDLE_FIELDS | _VISER_APPEARANCE_HANDLE_FIELDS
+)
+
+
+def _rotation_quat(from_vec: np.ndarray, to_vec: np.ndarray) -> np.ndarray:
+  """Quaternion (wxyz) that rotates ``from_vec`` to ``to_vec``."""
+  from_vec = from_vec / np.linalg.norm(from_vec)
+  to_vec = to_vec / np.linalg.norm(to_vec)
+  if np.allclose(from_vec, to_vec):
+    return _IDENTITY_QUAT.copy()
+  if np.allclose(from_vec, -to_vec):
+    perp = np.array([1.0, 0.0, 0.0])
+    if abs(from_vec[0]) > 0.9:
+      perp = np.array([0.0, 1.0, 0.0])
+    axis = np.cross(from_vec, perp)
+    axis = axis / np.linalg.norm(axis)
+    return np.array([0.0, axis[0], axis[1], axis[2]])
+  cross = np.cross(from_vec, to_vec)
+  dot = np.dot(from_vec, to_vec)
+  quat = np.array([1.0 + dot, cross[0], cross[1], cross[2]])
+  return quat / np.linalg.norm(quat)
+
+
+def _to_numpy(x: np.ndarray | torch.Tensor) -> np.ndarray:
+  if isinstance(x, torch.Tensor):
+    return x.cpu().numpy()
+  return x
+
+
+def _color_uint8(rgba: tuple[float, float, float, float]) -> np.ndarray:
+  return (np.array(rgba[:3]) * 255).astype(np.uint8)
+
+
+# Batched primitive handle.
+
+
+@dataclass
+class _BatchedPrimitive:
+  """Manages a single batched mesh handle with lazy mesh creation."""
+
+  name: str
+  mesh_factory: Callable[[], trimesh.Trimesh]
+  mesh: trimesh.Trimesh | None = field(default=None, repr=False)
+  handle: viser.BatchedMeshHandle | None = field(default=None, repr=False)
+
+  def remove(self) -> None:
+    if self.handle is not None:
+      self.handle.remove()
+      self.handle = None
+
+  def sync(
+    self,
+    server: viser.ViserServer,
+    env_idx: int,
+    positions: np.ndarray,
+    wxyzs: np.ndarray,
+    scales: np.ndarray,
+    colors: np.ndarray,
+    opacity: float = 1.0,
+  ) -> None:
+    """Create or update the batched mesh handle."""
+    if self.mesh is None:
+      self.mesh = self.mesh_factory()
+
+    needs_recreation = self.handle is None or len(positions) != len(
+      self.handle.batched_positions
+    )
+    if needs_recreation:
+      self.remove()
+      self.handle = server.scene.add_batched_meshes_simple(
+        f"/debug/env_{env_idx}/{self.name}",
+        self.mesh.vertices,
+        self.mesh.faces,
+        batched_wxyzs=wxyzs,
+        batched_positions=positions,
+        batched_scales=scales,
+        batched_colors=colors,
+        opacity=opacity,
+        cast_shadow=False,
+        receive_shadow=False,
+      )
+    else:
+      assert self.handle is not None
+      self.handle.batched_positions = positions
+      self.handle.batched_wxyzs = wxyzs
+      self.handle.batched_scales = scales
+      self.handle.batched_colors = colors
+
+
+@dataclass
+class _PerWorldMeshGroup:
+  handle: viser.BatchedGlbHandle
+  body_ids: np.ndarray
+  group_id: int
+  mocap_ids: np.ndarray | None
+  env_ids: np.ndarray
+
+
+@dataclass
+class _VariantMeshGroup:
+  mesh: trimesh.Trimesh
+  group_id: int
+  sub_idx: int
+  body_name: str
+  is_mocap: bool
+  env_ids: list[int] = field(default_factory=list)
+  body_ids: list[int] = field(default_factory=list)
+  mocap_ids: list[int] = field(default_factory=list)
+
+
+@dataclass
+class _PerWorldHullGroup:
+  """One convex-hull handle covering the envs that share a hull variant."""
+
+  handle: viser.BatchedMeshHandle
+  body_id: int
+  env_ids: np.ndarray
+
+
+@dataclass
+class _HullVariant:
+  body_id: int
+  vertices: np.ndarray
+  faces: np.ndarray
+  env_ids: list[int] = field(default_factory=list)
+
+
+def _compute_body_hull(
+  mj_model: mujoco.MjModel, geom_ids: list[int]
+) -> trimesh.Trimesh | None:
+  """Compute a merged convex hull for a body's mesh geoms.
+
+  Bypasses ``mjviser.merge_geoms_hull`` (which reads ``mesh_polynum`` and
+  returns ``None`` for any mesh that MuJoCo didn't compile polygon data for --
+  a situation that arises for later per-world-mesh variants). Uses the raw
+  ``mesh_vert`` / ``mesh_face`` arrays and trimesh's convex hull instead.
+  """
+  pieces: list[trimesh.Trimesh] = []
+  for geom_id in geom_ids:
+    if int(mj_model.geom_type[geom_id]) != int(mjtGeom.mjGEOM_MESH):
+      continue
+    mesh_id = int(mj_model.geom_dataid[geom_id])
+    if mesh_id < 0:
+      continue
+    vert_start = int(mj_model.mesh_vertadr[mesh_id])
+    vert_count = int(mj_model.mesh_vertnum[mesh_id])
+    if vert_count < 4:
+      continue
+    vertices = mj_model.mesh_vert[vert_start : vert_start + vert_count].copy()
+    try:
+      piece = trimesh.PointCloud(vertices).convex_hull
+    except Exception:
+      continue
+    transform = np.eye(4)
+    transform[:3, :3] = vtf.SO3(mj_model.geom_quat[geom_id]).as_matrix()
+    transform[:3, 3] = mj_model.geom_pos[geom_id]
+    piece.apply_transform(transform)
+    pieces.append(piece)
+  if not pieces:
+    return None
+  merged = pieces[0] if len(pieces) == 1 else trimesh.util.concatenate(pieces)
+  try:
+    return merged.convex_hull
+  except Exception:
+    return merged
+
+
+class MjlabViserScene(ViserMujocoScene, DebugVisualizer):
+  """ViserMujocoScene with debug visualization and warp tensor conversion.
+
+  Adds debug primitives (arrows, ghosts, spheres, cylinders, ellipsoids,
+  coordinate frames) on top of the base scene from mjviser.
+  """
+
+  def __init__(
+    self,
+    server: viser.ViserServer,
+    mj_model: mujoco.MjModel,
+    num_envs: int,
+    sim_model: Any | None = None,
+    expanded_fields: set[str] | None = None,
+  ) -> None:
+    self._sim_model = sim_model
+    self._expanded_fields = expanded_fields or set()
+    self._baked_appearance_fields = (
+      self._expanded_fields & _VISER_APPEARANCE_HANDLE_FIELDS
+    )
+    self._baked_appearance_fingerprint: tuple[tuple[str, bytes], ...] | None = None
+    self._use_per_world_mesh_groups = bool(
+      self._expanded_fields & _VISER_BAKED_HANDLE_FIELDS
+    )
+    # Populated by _build_hull_handles when per-world variants are active.
+    # Initialized here because ViserMujocoScene.__init__ calls our overrides
+    # of _compute_hull_body_meshes / _build_hull_handles during super().__init__.
+    self._hull_per_world_groups: list[_PerWorldHullGroup] = []
+    if self._sim_model is not None:
+      sync_model_fields(
+        mj_model,
+        self._sim_model,
+        self._expanded_fields & VIEWER_MODEL_FIELDS,
+        0,
+      )
+      disable_model_sameframe_shortcuts(mj_model)
+    super().__init__(server, mj_model, num_envs)
+    self._baked_appearance_fingerprint = self._appearance_fingerprint()
+
+    self.debug_visualization_enabled = False
+    self.show_all_envs = False
+
+    # Queued debug primitives (populated each frame, consumed by sync).
+    self._queued_arrows: list = []
+    self._queued_ghosts: list = []
+    self._queued_spheres: list = []
+    self._queued_cylinders: list = []
+    self._queued_ellipsoids: list = []
+    self._queued_boxes: list = []
+
+    # Batched mesh handles for simple primitives.
+    def _shaft_mesh() -> trimesh.Trimesh:
+      m = trimesh.creation.cylinder(radius=1.0, height=1.0)
+      m.apply_translation(np.array([0, 0, 0.5]))
+      return m
+
+    self._arrow_shafts = _BatchedPrimitive("arrow_shafts", _shaft_mesh)
+    self._arrow_heads = _BatchedPrimitive(
+      "arrow_heads",
+      lambda: trimesh.creation.cone(radius=2.0, height=1.0),
+    )
+    self._spheres = _BatchedPrimitive(
+      "spheres",
+      lambda: trimesh.creation.icosphere(subdivisions=2, radius=1.0),
+    )
+    self._cylinders = _BatchedPrimitive(
+      "cylinders",
+      lambda: trimesh.creation.cylinder(radius=1.0, height=1.0),
+    )
+    self._ellipsoids = _BatchedPrimitive(
+      "ellipsoids",
+      lambda: trimesh.creation.icosphere(subdivisions=2, radius=1.0),
+    )
+    # Unit half-extents so that scaling by the box size yields the requested
+    # half-extents (extents=2 spans -1 to 1 along each axis).
+    self._boxes = _BatchedPrimitive(
+      "boxes",
+      lambda: trimesh.creation.box(extents=(2.0, 2.0, 2.0)),
+    )
+    self._all_primitives = [
+      self._arrow_shafts,
+      self._arrow_heads,
+      self._spheres,
+      self._cylinders,
+      self._ellipsoids,
+      self._boxes,
+    ]
+
+    # Ghost mesh state.
+    self._ghost_handles: dict[tuple[int, int], viser.BatchedMeshHandle] = {}
+    self._ghost_meshes: dict[int, dict[int, trimesh.Trimesh]] = {}
+
+    # MjData used for ghost forward kinematics.
+    self._viz_data = mujoco.MjData(mj_model)
+
+  # Properties.
+
+  @property
+  @override
+  def meansize(self) -> float:
+    return self.meansize_override or self.mj_model.stat.meansize
+
+  # Update entry points.
+
+  def update(self, wp_data, env_idx: int | None = None) -> None:
+    """Update scene from batched mjwarp simulation data.
+
+    Converts warp GPU tensors to numpy arrays and delegates to
+    ``update_from_arrays``.
+    """
+    body_xpos = wp_data.xpos.cpu().numpy()
+    body_xmat = wp_data.xmat.cpu().numpy()
+    if self.mj_model.nmocap > 0:
+      mocap_pos = wp_data.mocap_pos.cpu().numpy()
+      mocap_quat = wp_data.mocap_quat.cpu().numpy()
+    else:
+      mocap_pos = None
+      mocap_quat = None
+
+    kwargs: dict[str, np.ndarray] = {}
+    if self._any_decor_visible():
+      kwargs["qpos"] = wp_data.qpos.cpu().numpy()
+      kwargs["qvel"] = wp_data.qvel.cpu().numpy()
+      if self.mj_model.nu > 0:
+        kwargs["ctrl"] = wp_data.ctrl.cpu().numpy()
+
+    self.update_from_arrays(
+      body_xpos,
+      body_xmat,
+      mocap_pos,
+      mocap_quat,
+      env_idx,
+      **kwargs,
+    )
+
+  @override
+  def update_from_arrays(
+    self,
+    body_xpos: np.ndarray,
+    body_xmat: np.ndarray,
+    mocap_pos: np.ndarray | None = None,
+    mocap_quat: np.ndarray | None = None,
+    env_idx: int | None = None,
+    qpos: np.ndarray | None = None,
+    qvel: np.ndarray | None = None,
+    ctrl: np.ndarray | None = None,
+  ) -> None:
+    """Update scene and sync debug visualizations."""
+    if env_idx is None:
+      env_idx = self.env_idx
+    self._sync_model_fields(env_idx)
+    super().update_from_arrays(
+      body_xpos,
+      body_xmat,
+      mocap_pos,
+      mocap_quat,
+      env_idx,
+      qpos=qpos,
+      qvel=qvel,
+      ctrl=ctrl,
+    )
+    self._sync_debug_visualizations(self._scene_offset)
+
+  @override
+  def update_from_mjdata(self, mj_data: mujoco.MjData) -> None:
+    """Update scene and sync debug visualizations."""
+    self._sync_model_fields(self.env_idx)
+    super().update_from_mjdata(mj_data)
+    self._sync_debug_visualizations(self._scene_offset)
+
+  def _sync_model_fields(self, env_idx: int) -> None:
+    """Sync visually relevant per-world model fields into the host MjModel."""
+    if self._sim_model is None:
+      return
+    fields = self._expanded_fields & VIEWER_MODEL_FIELDS
+    sync_model_fields(self.mj_model, self._sim_model, fields, env_idx)
+    self._rebuild_visual_handles_if_needed()
+
+  def _appearance_fingerprint(self) -> tuple[tuple[str, bytes], ...] | None:
+    """Return a stable fingerprint for fields baked into Viser mesh handles."""
+    if self._sim_model is None or not self._baked_appearance_fields:
+      return None
+    parts: list[tuple[str, bytes]] = []
+    for field_name in sorted(self._baked_appearance_fields):
+      value = getattr(self._sim_model, field_name).cpu().numpy()
+      parts.append((field_name, value.tobytes()))
+    return tuple(parts)
+
+  def _rebuild_visual_handles_if_needed(self) -> None:
+    if self._baked_appearance_fingerprint is None:
+      return
+    fingerprint = self._appearance_fingerprint()
+    if fingerprint == self._baked_appearance_fingerprint:
+      return
+    self._baked_appearance_fingerprint = fingerprint
+    self.rebuild_visual_handles()
+
+  @staticmethod
+  def _geom_subgroup_visual_fingerprint(
+    mj_model: mujoco.MjModel, geom_ids: list[int], is_mocap: bool
+  ) -> tuple[object, ...]:
+    parts: list[tuple[object, ...]] = []
+    for geom_id in geom_ids:
+      mat_id = int(mj_model.geom_matid[geom_id])
+      mat_rgba = (
+        tuple(mj_model.mat_rgba[mat_id].round(4).tolist()) if mat_id >= 0 else None
+      )
+      parts.append(
+        (
+          int(mj_model.geom_type[geom_id]),
+          int(mj_model.geom_dataid[geom_id]),
+          mat_id,
+          mat_rgba,
+          tuple(mj_model.geom_size[geom_id].round(6).tolist()),
+          tuple(mj_model.geom_rgba[geom_id].round(4).tolist()),
+          tuple(mj_model.geom_pos[geom_id].round(6).tolist()),
+          tuple(mj_model.geom_quat[geom_id].round(6).tolist()),
+        )
+      )
+    return (is_mocap, tuple(sorted(parts)))
+
+  @override
+  def _create_mesh_handles_by_group(self) -> None:
+    """Create dynamic mesh handles, respecting per-world mesh variants."""
+    if not self._use_per_world_mesh_groups:
+      super()._create_mesh_handles_by_group()
+      return
+
+    variants: dict[tuple[object, ...], _VariantMeshGroup] = {}
+    for env_idx in range(self.num_envs):
+      self._sync_model_fields(env_idx)
+      body_group_geoms: dict[tuple[int, int], list[int]] = {}
+      for geom_id in range(self.mj_model.ngeom):
+        body_id = int(self.mj_model.geom_bodyid[geom_id])
+        if is_fixed_body(self.mj_model, body_id):
+          continue
+        if self.mj_model.geom_rgba[geom_id, 3] == 0:
+          continue
+        if (
+          int(self.mj_model.geom_type[geom_id]) == int(mjtGeom.mjGEOM_MESH)
+          and int(self.mj_model.geom_dataid[geom_id]) < 0
+        ):
+          continue
+        group_id = int(self.mj_model.geom_group[geom_id])
+        body_group_geoms.setdefault((body_id, group_id), []).append(geom_id)
+
+      for (body_id, group_id), geom_ids in body_group_geoms.items():
+        subgroups = group_geoms_by_visual_compat(self.mj_model, geom_ids)
+        is_mocap = bool(self.mj_model.body_mocapid[body_id] >= 0)
+        for sub_idx, sub_geom_ids in enumerate(subgroups):
+          fp = self._geom_subgroup_visual_fingerprint(
+            self.mj_model, sub_geom_ids, is_mocap
+          )
+          key = (fp, group_id, sub_idx)
+          variant = variants.get(key)
+          if variant is None:
+            variant = _VariantMeshGroup(
+              mesh=merge_geoms(self.mj_model, sub_geom_ids),
+              group_id=group_id,
+              sub_idx=sub_idx,
+              body_name=get_body_name(self.mj_model, body_id),
+              is_mocap=is_mocap,
+            )
+            variants[key] = variant
+          variant.env_ids.append(env_idx)
+          variant.body_ids.append(body_id)
+          if is_mocap:
+            variant.mocap_ids.append(int(self.mj_model.body_mocapid[body_id]))
+
+    self._sync_model_fields(self.env_idx)
+    with self.server.atomic():
+      for variant_idx, variant in enumerate(variants.values()):
+        batch_count = len(variant.env_ids)
+        lod_ratio = 1000.0 / variant.mesh.vertices.shape[0]
+        suffix = f"/sub{variant.sub_idx}" if variant.sub_idx > 0 else ""
+        visible = (
+          0 <= variant.group_id < 6 and self.geom_groups_visible[variant.group_id]
+        )
+
+        handle = self.server.scene.add_batched_meshes_trimesh(
+          f"/bodies/{variant.body_name}/group{variant.group_id}"
+          f"/variant{variant_idx}{suffix}",
+          variant.mesh,
+          batched_wxyzs=np.tile([1.0, 0.0, 0.0, 0.0], (batch_count, 1)),
+          batched_positions=np.zeros((batch_count, 3)),
+          lod=((2.0, lod_ratio),) if lod_ratio < 0.5 else "off",
+          visible=visible,
+        )
+        cast(Any, self._mesh_groups).append(
+          _PerWorldMeshGroup(
+            handle=handle,
+            body_ids=np.asarray(variant.body_ids, dtype=np.int32),
+            group_id=variant.group_id,
+            mocap_ids=(
+              np.asarray(variant.mocap_ids, dtype=np.int32)
+              if variant.is_mocap
+              else None
+            ),
+            env_ids=np.asarray(variant.env_ids, dtype=np.int32),
+          )
+        )
+
+  @override
+  def _compute_hull_body_meshes(self) -> None:
+    """Record hull-bearing bodies across all variants; meshes built lazily."""
+    if not self._use_per_world_mesh_groups:
+      super()._compute_hull_body_meshes()
+      return
+    # Upstream caches one merged hull per body from the current mj_model.
+    # With per-world variants each env can have a different set of active
+    # mesh slots, so the actual hulls are computed per-variant in
+    # _build_hull_handles. Here we just record which bodies carry mesh hulls
+    # in any env so mjviser's _sync_visibilities / _hull_hide_meshes logic
+    # still has the right body set.
+    self._hull_body_meshes = {}
+    # Read the per-world geom_dataid table directly from sim_model: a body
+    # is a hull body iff any world has at least one active mesh geom on it,
+    # which is constant data we don't need to materialize per-env into
+    # mj_model to inspect.
+    assert self._sim_model is not None
+    dataid = self._sim_model.geom_dataid.cpu().numpy()
+    if dataid.ndim == 1:
+      dataid = dataid[None, :]
+    geom_active_in_any_world = (dataid >= 0).any(axis=0)
+    hull_bodies: set[int] = set()
+    for geom_id in range(self.mj_model.ngeom):
+      if int(self.mj_model.geom_type[geom_id]) != int(mjtGeom.mjGEOM_MESH):
+        continue
+      if not geom_active_in_any_world[geom_id]:
+        continue
+      hull_bodies.add(int(self.mj_model.geom_bodyid[geom_id]))
+    self._hull_mesh_bodies = hull_bodies
+
+  @override
+  def _build_hull_handles(self) -> None:
+    """Build one batched hull handle per (body, variant) across envs."""
+    if not self._use_per_world_mesh_groups:
+      super()._build_hull_handles()
+      return
+
+    color = np.array(self._hull_color, dtype=np.uint8)
+    opacity = float(self._hull_opacity)
+
+    # Group envs by (body_id, hull fingerprint). Fingerprint captures the
+    # fields that merge_geoms_hull actually reads (geom_dataid + local
+    # geom_pos/quat), so any two envs with identical fingerprints share the
+    # same hull mesh in body-local space.
+    variants: dict[tuple[int, tuple[object, ...]], _HullVariant] = {}
+    fixed_hull_bodies: dict[int, list[int]] = {}
+
+    for env_idx in range(self.num_envs):
+      self._sync_model_fields(env_idx)
+      body_geoms: dict[int, list[int]] = {}
+      for geom_id in range(self.mj_model.ngeom):
+        if int(self.mj_model.geom_type[geom_id]) != int(mjtGeom.mjGEOM_MESH):
+          continue
+        if int(self.mj_model.geom_dataid[geom_id]) < 0:
+          continue
+        body_id = int(self.mj_model.geom_bodyid[geom_id])
+        body_geoms.setdefault(body_id, []).append(geom_id)
+
+      for body_id, geom_ids in body_geoms.items():
+        if is_fixed_body(self.mj_model, body_id):
+          # Fixed bodies don't need per-env batching; defer to upstream
+          # single-hull path using env_idx 0 (already the default).
+          if env_idx == 0:
+            fixed_hull_bodies[body_id] = geom_ids
+          continue
+        fingerprint = tuple(
+          (
+            int(self.mj_model.geom_dataid[gid]),
+            tuple(float(x) for x in self.mj_model.geom_pos[gid].round(6)),
+            tuple(float(x) for x in self.mj_model.geom_quat[gid].round(6)),
+          )
+          for gid in geom_ids
+        )
+        key = (body_id, fingerprint)
+        v = variants.get(key)
+        if v is None:
+          hull = _compute_body_hull(self.mj_model, geom_ids)
+          if hull is None:
+            continue
+          v = _HullVariant(
+            body_id=body_id,
+            vertices=hull.vertices.astype(np.float32),
+            faces=hull.faces.astype(np.int32),
+          )
+          variants[key] = v
+        v.env_ids.append(env_idx)
+
+    # Fixed bodies: build one hull handle each (same body-local mesh for all
+    # envs since the body is welded). Uses env 0's synced state which is the
+    # default after the loop below.
+    self._sync_model_fields(self.env_idx)
+    for body_id, geom_ids in fixed_hull_bodies.items():
+      hull = _compute_body_hull(self.mj_model, geom_ids)
+      if hull is None:
+        continue
+      body = self.mj_model.body(body_id)
+      fixed_opacities = (
+        None if opacity >= 1.0 else np.array([opacity], dtype=np.float32)
+      )
+      handle = self.server.scene.add_batched_meshes_simple(
+        f"/fixed_bodies/hull/{body_id}",
+        hull.vertices.astype(np.float32),
+        hull.faces.astype(np.int32),
+        batched_wxyzs=np.array([[1.0, 0.0, 0.0, 0.0]], dtype=np.float32),
+        batched_positions=np.zeros((1, 3), dtype=np.float32),
+        batched_colors=color[None],
+        batched_opacities=fixed_opacities,
+        position=body.pos,
+        wxyz=body.quat,
+        visible=self._show_convex_hull,
+        cast_shadow=False,
+        receive_shadow=False,
+        lod="off",
+      )
+      self._hull_fixed_handles[body_id] = handle
+
+    self._hull_dynamic_handles = []
+    self._hull_per_world_groups = []
+    for variant_idx, ((body_id, _fp), v) in enumerate(variants.items()):
+      env_ids = np.asarray(v.env_ids, dtype=np.int32)
+      batch_count = int(env_ids.size)
+      dynamic_opacities = (
+        None if opacity >= 1.0 else np.full(batch_count, opacity, dtype=np.float32)
+      )
+      handle = self.server.scene.add_batched_meshes_simple(
+        f"/hull/{body_id}/variant{variant_idx}",
+        v.vertices,
+        v.faces,
+        batched_wxyzs=np.tile([1.0, 0.0, 0.0, 0.0], (batch_count, 1)).astype(
+          np.float32
+        ),
+        batched_positions=np.zeros((batch_count, 3), dtype=np.float32),
+        batched_colors=np.tile(color, (batch_count, 1)),
+        batched_opacities=dynamic_opacities,
+        visible=self._show_convex_hull,
+        cast_shadow=False,
+        receive_shadow=False,
+        lod="off",
+      )
+      self._hull_per_world_groups.append(
+        _PerWorldHullGroup(handle=handle, body_id=body_id, env_ids=env_ids)
+      )
+      # Also register in the upstream list so show_convex_hull.setter and
+      # any other base-class consumer still see every dynamic hull handle.
+      self._hull_dynamic_handles.append((handle, body_id))
+
+  @override
+  def _clear_hull_handles(self) -> None:
+    super()._clear_hull_handles()
+    self._hull_per_world_groups = []
+
+  @override
+  def _update_visualization_locked(
+    self,
+    body_xpos: np.ndarray,
+    body_xmat: np.ndarray,
+    mocap_pos: np.ndarray,
+    mocap_quat: np.ndarray,
+    env_idx: int,
+    scene_offset: np.ndarray,
+    mj_data: mujoco.MjData | None = None,
+  ) -> None:
+    if not self._use_per_world_mesh_groups:
+      super()._update_visualization_locked(
+        body_xpos, body_xmat, mocap_pos, mocap_quat, env_idx, scene_offset, mj_data
+      )
+      return
+
+    self._last_body_xpos = body_xpos
+    self._last_body_xmat = body_xmat
+    self._last_mocap_pos = mocap_pos
+    self._last_mocap_quat = mocap_quat
+    self._last_env_idx = env_idx
+    self._scene_offset = scene_offset
+    if mj_data is not None:
+      self._last_mj_data = mj_data
+
+    self.fixed_bodies_frame.position = scene_offset
+    slice_single = self.show_only_selected and self.num_envs > 1
+    hidden_bodies: set[int] = set()
+    if self._show_convex_hull and self._hull_hide_meshes:
+      hidden_bodies = self._hull_mesh_bodies
+    if (
+      self._mjv_option.flags[mujoco.mjtVisFlag.mjVIS_AUTOCONNECT]
+      and self._autoconnect_hide_meshes
+    ):
+      hidden_bodies |= set(range(self.mj_model.nbody))
+
+    with self.server.atomic():
+      body_xquat = vtf.SO3.from_matrix(body_xmat).wxyz
+      for mg in self._mesh_groups:
+        if isinstance(mg, _PerWorldMeshGroup):
+          visible = 0 <= mg.group_id < 6 and self.geom_groups_visible[mg.group_id]
+          if visible and any(body_id in hidden_bodies for body_id in mg.body_ids):
+            visible = False
+          if not visible:
+            mg.handle.visible = False
+            continue
+
+          env_ids = mg.env_ids
+          body_ids = mg.body_ids
+          mocap_ids = mg.mocap_ids
+          if slice_single:
+            mask = env_ids == env_idx
+            if not np.any(mask):
+              mg.handle.visible = False
+              continue
+            env_ids = env_ids[mask]
+            body_ids = body_ids[mask]
+            if mocap_ids is not None:
+              mocap_ids = mocap_ids[mask]
+          if mocap_ids is not None:
+            pos = mocap_pos[env_ids, mocap_ids] + scene_offset
+            quat = mocap_quat[env_ids, mocap_ids]
+          else:
+            pos = body_xpos[env_ids, body_ids] + scene_offset
+            quat = body_xquat[env_ids, body_ids]
+          mg.handle.batched_positions = pos
+          mg.handle.batched_wxyzs = quat
+          mg.handle.visible = True
+          continue
+
+        if not mg.handle.visible:
+          continue
+        if mg.mocap_ids is not None:
+          pos, quat = self._batched_transform_group(
+            mocap_pos, mocap_quat, mg.mocap_ids, env_idx, scene_offset, slice_single
+          )
+        else:
+          pos, quat = self._batched_transform_group(
+            body_xpos, body_xquat, mg.body_ids, env_idx, scene_offset, slice_single
+          )
+        mg.handle.batched_positions = pos
+        mg.handle.batched_wxyzs = quat
+
+      for (body_id, _), handle in self.site_handles_by_group.items():
+        if not handle.visible:
+          continue
+        pos, quat = self._batched_transform(
+          body_xpos, body_xquat, body_id, env_idx, scene_offset, slice_single
+        )
+        handle.batched_positions = pos
+        handle.batched_wxyzs = quat
+
+      if self._show_convex_hull:
+        for hg in self._hull_per_world_groups:
+          env_ids = hg.env_ids
+          body_id = hg.body_id
+          if slice_single:
+            mask = env_ids == env_idx
+            if not np.any(mask):
+              hg.handle.visible = False
+              continue
+            env_ids = env_ids[mask]
+          pos = body_xpos[env_ids, body_id] + scene_offset
+          quat = body_xquat[env_ids, body_id]
+          hg.handle.batched_positions = pos
+          hg.handle.batched_wxyzs = quat
+          hg.handle.visible = True
+
+      if self._any_decor_visible() and mj_data is not None:
+        self._update_decor_from_mjvscene(mj_data, scene_offset)
+      elif not self._any_decor_visible():
+        self._clear_decor_handles()
+
+      self.server.flush()
+
+  # Refresh.
+
+  @override
+  def refresh_visualization(self) -> None:
+    """Re-render, keeping needs_update set when debug viz is active."""
+    super().refresh_visualization()
+    self._sync_debug_visualizations(self._scene_offset)
+    if self.debug_visualization_enabled:
+      self.needs_update = True
+
+  # GUI.
+
+  @override
+  def create_scene_gui(
+    self,
+    camera_distance: float = 3.0,
+    camera_azimuth: float = 45.0,
+    camera_elevation: float = 30.0,
+    show_debug_viz_control: bool = True,
+    debug_viz_extra_gui: Callable[[], None] | None = None,
+  ) -> None:
+    """Add standard GUI controls plus debug visualization section."""
+    super().create_scene_gui(
+      camera_distance=camera_distance,
+      camera_azimuth=camera_azimuth,
+      camera_elevation=camera_elevation,
+    )
+
+    if show_debug_viz_control:
+      with self.server.gui.add_folder("Debug Viz"):
+        cb_debug_vis = self.server.gui.add_checkbox(
+          "Enabled",
+          initial_value=self.debug_visualization_enabled,
+          hint="Show debug arrows and ghost meshes.",
+        )
+
+        @cb_debug_vis.on_update
+        def _(_) -> None:
+          self.debug_visualization_enabled = cb_debug_vis.value
+          if not self.debug_visualization_enabled:
+            self.clear_debug_all()
+          self.request_update()
+
+        cb_show_all_envs = self.server.gui.add_checkbox(
+          "All envs",
+          initial_value=self.show_all_envs,
+          hint="Show debug visualization for all environments.",
+        )
+
+        @cb_show_all_envs.on_update
+        def _(_) -> None:
+          self.show_all_envs = cb_show_all_envs.value
+          if not self.show_all_envs:
+            self.clear_debug_all()
+          self.request_update()
+
+        if debug_viz_extra_gui is not None:
+          debug_viz_extra_gui()
+
+  # DebugVisualizer ABC implementation.
+
+  @override
+  def add_arrow(
+    self,
+    start: np.ndarray | torch.Tensor,
+    end: np.ndarray | torch.Tensor,
+    color: tuple[float, float, float, float],
+    width: float = 0.015,
+    label: str | None = None,
+  ) -> None:
+    if not self.debug_visualization_enabled:
+      return
+    del label
+    start, end = _to_numpy(start), _to_numpy(end)
+    if np.linalg.norm(end - start) < 1e-6:
+      return
+    self._queued_arrows.append((start, end, color, width))
+
+  @override
+  def add_ghost_mesh(
+    self,
+    qpos: np.ndarray | torch.Tensor,
+    model: mujoco.MjModel,
+    mocap_pos: np.ndarray | torch.Tensor | None = None,
+    mocap_quat: np.ndarray | torch.Tensor | None = None,
+    alpha: float = 0.5,
+    label: str | None = None,
+  ) -> None:
+    if not self.debug_visualization_enabled:
+      return
+    qpos = _to_numpy(qpos)
+    mocap_pos = _to_numpy(mocap_pos) if mocap_pos is not None else None
+    mocap_quat = _to_numpy(mocap_quat) if mocap_quat is not None else None
+    self._queued_ghosts.append(
+      (
+        qpos.copy(),
+        model,
+        np.asarray(mocap_pos).copy() if mocap_pos is not None else None,
+        np.asarray(mocap_quat).copy() if mocap_quat is not None else None,
+        alpha,
+        label or f"env_{self.env_idx}",
+      )
+    )
+
+  @override
+  def add_frame(
+    self,
+    position: np.ndarray | torch.Tensor,
+    rotation_matrix: np.ndarray | torch.Tensor,
+    scale: float = 0.3,
+    label: str | None = None,
+    axis_radius: float = 0.01,
+    alpha: float = 1.0,
+    axis_colors: (tuple[tuple[float, float, float], ...] | None) = None,
+  ) -> None:
+    if not self.debug_visualization_enabled:
+      return
+    del label
+    position = _to_numpy(position)
+    rotation_matrix = _to_numpy(rotation_matrix)
+    colors = axis_colors or [(0.9, 0, 0), (0, 0.9, 0), (0, 0, 0.9)]
+    for axis_idx in range(3):
+      end = position + rotation_matrix[:, axis_idx] * scale
+      rgb = colors[axis_idx]
+      self.add_arrow(
+        start=position,
+        end=end,
+        color=(rgb[0], rgb[1], rgb[2], alpha),
+        width=axis_radius,
+      )
+
+  @override
+  def add_sphere(
+    self,
+    center: np.ndarray | torch.Tensor,
+    radius: float,
+    color: tuple[float, float, float, float],
+    label: str | None = None,
+  ) -> None:
+    if not self.debug_visualization_enabled:
+      return
+    del label
+    self._queued_spheres.append((_to_numpy(center).copy(), radius, color))
+
+  @override
+  def add_cylinder(
+    self,
+    start: np.ndarray | torch.Tensor,
+    end: np.ndarray | torch.Tensor,
+    radius: float,
+    color: tuple[float, float, float, float],
+    label: str | None = None,
+  ) -> None:
+    if not self.debug_visualization_enabled:
+      return
+    del label
+    start, end = _to_numpy(start), _to_numpy(end)
+    self._queued_cylinders.append((start.copy(), end.copy(), radius, color))
+
+  @override
+  def add_ellipsoid(
+    self,
+    center: np.ndarray | torch.Tensor,
+    size: np.ndarray | torch.Tensor,
+    mat: np.ndarray | torch.Tensor,
+    color: tuple[float, float, float, float],
+    label: str | None = None,
+  ) -> None:
+    if not self.debug_visualization_enabled:
+      return
+    del label
+    self._queued_ellipsoids.append(
+      (
+        np.asarray(_to_numpy(center), dtype=np.float32).copy(),
+        np.asarray(_to_numpy(size), dtype=np.float32).copy(),
+        np.asarray(_to_numpy(mat), dtype=np.float32).reshape(3, 3).copy(),
+        color,
+      )
+    )
+
+  @override
+  def add_box(
+    self,
+    center: np.ndarray | torch.Tensor,
+    size: np.ndarray | torch.Tensor,
+    mat: np.ndarray | torch.Tensor,
+    color: tuple[float, float, float, float],
+    label: str | None = None,
+  ) -> None:
+    if not self.debug_visualization_enabled:
+      return
+    del label
+    self._queued_boxes.append(
+      (
+        np.asarray(_to_numpy(center), dtype=np.float32).copy(),
+        np.asarray(_to_numpy(size), dtype=np.float32).copy(),
+        np.asarray(_to_numpy(mat), dtype=np.float32).reshape(3, 3).copy(),
+        color,
+      )
+    )
+
+  @override
+  def clear(self) -> None:
+    """Clear all debug visualization queues."""
+    self._queued_arrows.clear()
+    self._queued_spheres.clear()
+    self._queued_cylinders.clear()
+    self._queued_ellipsoids.clear()
+    self._queued_boxes.clear()
+    self._queued_ghosts.clear()
+
+  def clear_debug_all(self) -> None:
+    """Clear all debug visualizations including handles."""
+    self.clear()
+    for prim in self._all_primitives:
+      prim.remove()
+    for handle in self._ghost_handles.values():
+      handle.visible = False
+
+  # Debug sync.
+
+  def _sync_debug_visualizations(self, scene_offset: np.ndarray) -> None:
+    if not self.debug_visualization_enabled:
+      return
+    self._scene_offset = scene_offset
+    self._sync_arrows()
+    self._sync_simple_primitives()
+    self._sync_ghosts()
+
+  def _sync_arrows(self) -> None:
+    if not self._queued_arrows:
+      self._arrow_shafts.remove()
+      self._arrow_heads.remove()
+      return
+
+    n = len(self._queued_arrows)
+    shaft_pos = np.zeros((n, 3), dtype=np.float32)
+    shaft_wxyz = np.zeros((n, 4), dtype=np.float32)
+    shaft_scale = np.zeros((n, 3), dtype=np.float32)
+    shaft_col = np.zeros((n, 3), dtype=np.uint8)
+    head_pos = np.zeros((n, 3), dtype=np.float32)
+    head_wxyz = np.zeros((n, 4), dtype=np.float32)
+    head_scale = np.zeros((n, 3), dtype=np.float32)
+    head_col = np.zeros((n, 3), dtype=np.uint8)
+
+    for i, (start, end, color, width) in enumerate(self._queued_arrows):
+      s = start + self._scene_offset
+      e = end + self._scene_offset
+      d = e - s
+      length = np.linalg.norm(d)
+      d = d / length
+      q = _rotation_quat(_Z_AXIS, d)
+      c = _color_uint8(color)
+
+      shaft_len = 0.8 * length
+      shaft_pos[i] = s
+      shaft_wxyz[i] = q
+      shaft_scale[i] = [width, width, shaft_len]
+      shaft_col[i] = c
+
+      head_pos[i] = s + d * shaft_len
+      head_wxyz[i] = q
+      head_scale[i] = [width, width, 0.2 * length]
+      head_col[i] = c
+
+    self._arrow_shafts.sync(
+      self.server,
+      self.env_idx,
+      shaft_pos,
+      shaft_wxyz,
+      shaft_scale,
+      shaft_col,
+    )
+    self._arrow_heads.sync(
+      self.server,
+      self.env_idx,
+      head_pos,
+      head_wxyz,
+      head_scale,
+      head_col,
+    )
+
+  def _sync_simple_primitives(self) -> None:
+    self._sync_spheres()
+    self._sync_cylinders()
+    self._sync_ellipsoids()
+    self._sync_boxes()
+
+  def _sync_spheres(self) -> None:
+    if not self._queued_spheres:
+      self._spheres.remove()
+      return
+    n = len(self._queued_spheres)
+    positions = np.zeros((n, 3), dtype=np.float32)
+    wxyzs = np.tile(_IDENTITY_QUAT, (n, 1)).astype(np.float32)
+    scales = np.zeros((n, 3), dtype=np.float32)
+    colors = np.zeros((n, 3), dtype=np.uint8)
+    opacity = 1.0
+    for i, (center, radius, color) in enumerate(self._queued_spheres):
+      positions[i] = center + self._scene_offset
+      scales[i] = radius
+      colors[i] = _color_uint8(color)
+      opacity = color[3]
+    self._spheres.sync(
+      self.server,
+      self.env_idx,
+      positions,
+      wxyzs,
+      scales,
+      colors,
+      opacity,
+    )
+
+  def _sync_cylinders(self) -> None:
+    if not self._queued_cylinders:
+      self._cylinders.remove()
+      return
+    n = len(self._queued_cylinders)
+    positions = np.zeros((n, 3), dtype=np.float32)
+    wxyzs = np.zeros((n, 4), dtype=np.float32)
+    scales = np.zeros((n, 3), dtype=np.float32)
+    colors = np.zeros((n, 3), dtype=np.uint8)
+    opacity = 1.0
+    for i, (start, end, radius, color) in enumerate(self._queued_cylinders):
+      s = start + self._scene_offset
+      e = end + self._scene_offset
+      d = e - s
+      length = np.linalg.norm(d)
+      if length < 1e-6:
+        positions[i] = s
+        wxyzs[i] = _IDENTITY_QUAT
+      else:
+        positions[i] = (s + e) / 2
+        wxyzs[i] = _rotation_quat(_Z_AXIS, d / length)
+        scales[i] = [radius, radius, length]
+      colors[i] = _color_uint8(color)
+      opacity = color[3]
+    self._cylinders.sync(
+      self.server,
+      self.env_idx,
+      positions,
+      wxyzs,
+      scales,
+      colors,
+      opacity,
+    )
+
+  def _sync_ellipsoids(self) -> None:
+    if not self._queued_ellipsoids:
+      self._ellipsoids.remove()
+      return
+    n = len(self._queued_ellipsoids)
+    positions = np.zeros((n, 3), dtype=np.float32)
+    wxyzs = np.zeros((n, 4), dtype=np.float32)
+    scales = np.zeros((n, 3), dtype=np.float32)
+    colors = np.zeros((n, 3), dtype=np.uint8)
+    opacity = 1.0
+    for i, (center, size, mat, color) in enumerate(self._queued_ellipsoids):
+      positions[i] = center + self._scene_offset
+      wxyzs[i] = vtf.SO3.from_matrix(mat).wxyz
+      scales[i] = size
+      colors[i] = _color_uint8(color)
+      opacity = color[3]
+    self._ellipsoids.sync(
+      self.server,
+      self.env_idx,
+      positions,
+      wxyzs,
+      scales,
+      colors,
+      opacity,
+    )
+
+  def _sync_boxes(self) -> None:
+    if not self._queued_boxes:
+      self._boxes.remove()
+      return
+    n = len(self._queued_boxes)
+    positions = np.zeros((n, 3), dtype=np.float32)
+    wxyzs = np.zeros((n, 4), dtype=np.float32)
+    scales = np.zeros((n, 3), dtype=np.float32)
+    colors = np.zeros((n, 3), dtype=np.uint8)
+    opacity = 1.0
+    for i, (center, size, mat, color) in enumerate(self._queued_boxes):
+      positions[i] = center + self._scene_offset
+      wxyzs[i] = vtf.SO3.from_matrix(mat).wxyz
+      scales[i] = size
+      colors[i] = _color_uint8(color)
+      opacity = color[3]
+    self._boxes.sync(
+      self.server,
+      self.env_idx,
+      positions,
+      wxyzs,
+      scales,
+      colors,
+      opacity,
+    )
+
+  def _sync_ghosts(self) -> None:
+    """Render queued ghosts as one batched handle per (model, body)."""
+    if not self._queued_ghosts:
+      for handle in self._ghost_handles.values():
+        handle.visible = False
+      return
+
+    body_data: dict[
+      tuple[int, int],
+      list[tuple[np.ndarray, np.ndarray, np.ndarray]],
+    ] = {}
+    alpha_by_model: dict[int, float] = {}
+
+    for qpos, model, mocap_pos, mocap_quat, alpha, _label in self._queued_ghosts:
+      model_id = id(model)
+      alpha_by_model[model_id] = alpha
+
+      # Forward kinematics on the visualization-only MjData.
+      self._viz_data.qpos[:] = qpos
+      if mocap_pos is not None and model.nmocap > 0:
+        if mocap_pos.ndim == 1:
+          self._viz_data.mocap_pos[0] = mocap_pos
+        else:
+          self._viz_data.mocap_pos[:] = mocap_pos
+      if mocap_quat is not None and model.nmocap > 0:
+        if mocap_quat.ndim == 1:
+          self._viz_data.mocap_quat[0] = mocap_quat
+        else:
+          self._viz_data.mocap_quat[:] = mocap_quat
+      mujoco.mj_forward(model, self._viz_data)
+
+      # Group visible ghost geoms by body.
+      body_geoms: dict[int, list[int]] = {}
+      for gi in range(model.ngeom):
+        if model.geom_rgba[gi, 3] == 0:
+          continue
+        bid = model.geom_bodyid[gi]
+        if model.body_dofnum[bid] == 0 and model.body_parentid[bid] == 0:
+          continue
+        body_geoms.setdefault(bid, []).append(gi)
+
+      for bid, bid_geom_ids in body_geoms.items():
+        key = (model_id, bid)
+        body_data.setdefault(key, []).append(
+          (
+            (self._viz_data.xpos[bid] + self._scene_offset).copy(),
+            vtf.SO3.from_matrix(self._viz_data.xmat[bid].reshape(3, 3)).wxyz.copy(),
+            (model.geom_rgba[bid_geom_ids[0]][:3] * 255).astype(np.uint8),
+          )
+        )
+
+        # Cache combined mesh per (model, body).
+        by_model = self._ghost_meshes.setdefault(model_id, {})
+        if bid not in by_model:
+          meshes = []
+          for gid in bid_geom_ids:
+            mesh = _create_geom_mesh(model, gid)
+            if mesh is not None:
+              T = np.eye(4)
+              T[:3, :3] = vtf.SO3(model.geom_quat[gid]).as_matrix()
+              T[:3, 3] = model.geom_pos[gid]
+              mesh.apply_transform(T)
+              meshes.append(mesh)
+          if meshes:
+            by_model[bid] = (
+              meshes[0] if len(meshes) == 1 else trimesh.util.concatenate(meshes)
+            )
+
+    # Remove stale handles.
+    for key in set(self._ghost_handles) - set(body_data):
+      self._ghost_handles.pop(key).remove()
+
+    # Create or update handles.
+    for (model_id, bid), transforms in body_data.items():
+      mesh = self._ghost_meshes.get(model_id, {}).get(bid)
+      if mesh is None:
+        continue
+
+      positions = np.array([t[0] for t in transforms], dtype=np.float32)
+      wxyzs = np.array([t[1] for t in transforms], dtype=np.float32)
+      colors = np.array([t[2] for t in transforms], dtype=np.uint8)
+      alpha = alpha_by_model.get(model_id, 0.5)
+      key = (model_id, bid)
+
+      if key not in self._ghost_handles:
+        self._ghost_handles[key] = self.server.scene.add_batched_meshes_simple(
+          f"/debug/ghosts/body_{bid}_{model_id}",
+          mesh.vertices,
+          mesh.faces,
+          batched_wxyzs=wxyzs,
+          batched_positions=positions,
+          batched_colors=colors,
+          opacity=alpha,
+          cast_shadow=False,
+          receive_shadow=False,
+        )
+      else:
+        handle = self._ghost_handles[key]
+        try:
+          handle.batched_positions = positions
+          handle.batched_wxyzs = wxyzs
+          handle.batched_colors = colors
+          handle.visible = True
+        except Exception:
+          handle.remove()
+          self._ghost_handles[key] = self.server.scene.add_batched_meshes_simple(
+            f"/debug/ghosts/body_{bid}_{model_id}",
+            mesh.vertices,
+            mesh.faces,
+            batched_wxyzs=wxyzs,
+            batched_positions=positions,
+            batched_colors=colors,
+            opacity=alpha,
+            cast_shadow=False,
+            receive_shadow=False,
+          )
+
+
+# Helpers.
+
+
+def _create_geom_mesh(mj_model: mujoco.MjModel, geom_id: int) -> trimesh.Trimesh | None:
+  if mj_model.geom_type[geom_id] == mjtGeom.mjGEOM_MESH:
+    return mujoco_mesh_to_trimesh(mj_model, geom_id)
+  return create_primitive_mesh(mj_model, geom_id)
diff --git a/src/mjlab/viewer/viser/term_plotter.py b/src/mjlab/viewer/viser/term_plotter.py
new file mode 100644
index 0000000..6bfd7b0
--- /dev/null
+++ b/src/mjlab/viewer/viser/term_plotter.py
@@ -0,0 +1,235 @@
+"""Plotting functionality for Viser viewer."""
+
+from __future__ import annotations
+
+from collections import deque
+from dataclasses import dataclass, field
+
+import numpy as np
+import viser
+import viser.uplot
+
+_PALETTE = [
+  "#1f77b4",  # blue
+  "#ff7f0e",  # orange
+  "#2ca02c",  # green
+  "#d62728",  # red
+  "#9467bd",  # purple
+  "#8c564b",  # brown
+  "#e377c2",  # pink
+  "#7f7f7f",  # gray
+  "#bcbd22",  # olive
+  "#17becf",  # cyan
+  "#aec7e8",  # light blue
+  "#ffbb78",  # light orange
+]
+
+
+def _color_for(index: int) -> str:
+  return _PALETTE[index % len(_PALETTE)]
+
+
+@dataclass
+class _TermState:
+  """Mutable state for a single term."""
+
+  name: str
+  color: str
+  enabled: bool = False
+  history: deque[float] = field(default_factory=lambda: deque(maxlen=300))
+  plot: viser.GuiUplotHandle | None = None
+
+
+class ViserTermPlotter:
+  """Handles plotting for the Viser viewer with selective display."""
+
+  def __init__(
+    self,
+    server: viser.ViserServer,
+    term_names: list[str],
+    name: str = "Reward",
+    history_length: int = 150,
+    env_idx: int = 0,
+  ) -> None:
+    """Initialize the plotter.
+
+    Args:
+      server: The Viser server instance
+      term_names: List of term names to plot
+      name: Name prefix for the plots (e.g. "Reward" or "Metric")
+      history_length: Number of points to keep in history
+      env_idx: Index of the environment being displayed
+    """
+    self._server = server
+    self._name = name
+    self._history_length = history_length
+
+    # Pre-allocated x-axis array (reused for all plots).
+    self._x_array = np.arange(-history_length + 1, 1, dtype=np.float64)
+
+    # Stable color assignment.
+    self._terms: dict[str, _TermState] = {}
+    for i, tname in enumerate(term_names):
+      self._terms[tname] = _TermState(
+        name=tname,
+        color=_color_for(i),
+        history=deque(maxlen=history_length),
+      )
+
+    # GUI handles.
+    self._checkboxes: dict[str, viser.GuiInputHandle] = {}
+
+    self._empty = np.array([], dtype=np.float64)
+
+    self._env_idx = env_idx
+
+    # Build all GUI elements.
+    self._build_selector_gui(term_names)
+    self._plots_folder = self._server.gui.add_folder("Plots", expand_by_default=True)
+
+  def _build_selector_gui(self, term_names: list[str]) -> None:
+    """Build flat checkboxes with a filter input for term selection."""
+    with self._server.gui.add_folder("Select terms", expand_by_default=True):
+      self._env_label = self._server.gui.add_markdown(self._env_label_text())
+
+      # Filter input.
+      self._filter_input = self._server.gui.add_text(
+        "Filter",
+        initial_value="",
+        hint="Term name must contain this string",
+      )
+
+      @self._filter_input.on_update
+      def _(_) -> None:
+        filter_str = self._filter_input.value.lower()
+        for tname, state in self._terms.items():
+          cb = self._checkboxes[tname]
+          visible = filter_str in tname.lower()
+          cb.visible = visible
+          if not visible:
+            if state.plot is not None:
+              state.plot.remove()
+              state.plot = None
+          elif state.enabled and state.plot is None:
+            self._create_plot(state)
+
+      # Bulk actions.
+      bulk = self._server.gui.add_button_group("Select", options=["All", "None"])
+
+      @bulk.on_click
+      def _(event) -> None:
+        enable = event.target.value == "All"
+        for tname, state in self._terms.items():
+          cb = self._checkboxes[tname]
+          if cb.visible:
+            state.enabled = enable
+            cb.value = enable
+        self._sync_plots()
+
+      # Flat checkbox list.
+      for tname in term_names:
+        state = self._terms[tname]
+        cb = self._server.gui.add_checkbox(
+          tname,
+          initial_value=state.enabled,
+          hint=f"Color: {state.color}",
+        )
+        self._checkboxes[tname] = cb
+
+        @cb.on_update
+        def _(event, _tname=tname) -> None:
+          self._terms[_tname].enabled = event.target.value
+          self._sync_plots()
+
+  def _env_label_text(self) -> str:
+    return f"<small><em>Showing terms for environment #{self._env_idx}</em></small>"
+
+  def update_env_idx(self, env_idx: int) -> None:
+    """Update the displayed environment index."""
+    self._env_idx = env_idx
+    self._env_label.content = self._env_label_text()
+
+  def _sync_plots(self) -> None:
+    """Create or remove plots to match current selection."""
+    for tname, state in self._terms.items():
+      cb = self._checkboxes[tname]
+      should_show = state.enabled and cb.visible
+      if should_show and state.plot is None:
+        self._create_plot(state)
+      elif not should_show and state.plot is not None:
+        state.plot.remove()
+        state.plot = None
+
+  def _create_plot(self, state: _TermState) -> None:
+    """Lazily create a single-term plot inside the scoped folder."""
+    h = state.history
+    hist_len = len(h)
+    if hist_len > 0:
+      x = self._x_array[-hist_len:]
+      y = np.fromiter(h, dtype=np.float64, count=hist_len)
+    else:
+      x = self._empty
+      y = self._empty
+
+    with self._plots_folder:
+      state.plot = self._server.gui.add_uplot(
+        data=(x, y),
+        series=(
+          viser.uplot.Series(label="Steps"),
+          viser.uplot.Series(label=state.name, stroke=state.color, width=2),
+        ),
+        scales={
+          "x": viser.uplot.Scale(
+            time=False, auto=False, range=(-self._history_length, 0)
+          ),
+          "y": viser.uplot.Scale(auto=True),
+        },
+        legend=viser.uplot.Legend(show=True),
+        title=state.name,
+        aspect=2.0,
+        visible=True,
+      )
+
+  def update(self, terms: list[tuple[str, np.ndarray]]) -> None:
+    """Push new data and refresh visible plots."""
+    any_enabled = False
+    for tname, arr in terms:
+      state = self._terms.get(tname)
+      if state is None:
+        continue
+      val = float(arr[0])
+      if np.isfinite(val):
+        state.history.append(val)
+      if state.enabled:
+        any_enabled = True
+
+    if not any_enabled:
+      return
+
+    # Update plots.
+    for state in self._terms.values():
+      if not state.enabled or state.plot is None:
+        continue
+      h = state.history
+      hist_len = len(h)
+      if hist_len > 0:
+        x = self._x_array[-hist_len:]
+        y = np.fromiter(h, dtype=np.float64, count=hist_len)
+        state.plot.data = (x, y)
+
+  def clear_histories(self) -> None:
+    """Clear all term histories."""
+    for state in self._terms.values():
+      state.history.clear()
+      if state.plot is not None:
+        state.plot.data = (self._empty, self._empty)
+
+  def cleanup(self) -> None:
+    """Clean up resources."""
+    for state in self._terms.values():
+      if state.plot is not None:
+        state.plot.remove()
+    for cb in self._checkboxes.values():
+      cb.remove()
+    self._terms.clear()
+    self._checkboxes.clear()
diff --git a/src/mjlab/viewer/viser/viewer.py b/src/mjlab/viewer/viser/viewer.py
new file mode 100644
index 0000000..fe59e3b
--- /dev/null
+++ b/src/mjlab/viewer/viser/viewer.py
@@ -0,0 +1,574 @@
+"""mjlab play viewer based on Viser with simulation controls.
+
+Adapted from an MJX visualizer by Chung Min Kim: https://github.com/chungmin99/
+"""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from enum import Enum, auto
+from threading import Event, Lock
+from typing import Any, Optional
+
+import torch
+import viser
+from typing_extensions import override
+
+from mjlab.sensor.raycast_sensor import RayCastSensor
+from mjlab.sim.sim import Simulation
+from mjlab.viewer.base import (
+  BaseViewer,
+  EnvProtocol,
+  PolicyProtocol,
+  VerbosityLevel,
+  ViewerAction,
+)
+from mjlab.viewer.viser.overlays import (
+  ViserCameraOverlays,
+  ViserContactOverlays,
+  ViserDebugOverlays,
+  ViserTermOverlays,
+)
+from mjlab.viewer.viser.scene import MjlabViserScene
+
+
+@dataclass
+class CheckpointManager:
+  """Holds checkpoint discovery and loading callbacks for the viewer."""
+
+  current_name: str
+  fetch_available: Callable[[], list[tuple[str, str]]]
+  load_checkpoint: Callable[[str], PolicyProtocol]
+  run_name: str | None = None
+  run_url: str | None = None
+  run_status: str | None = None
+
+
+def format_time_ago(seconds: int) -> str:
+  """Format a duration in seconds as a human-readable time-ago string."""
+  for div, unit in ((86400, "d"), (3600, "h"), (60, "m")):
+    if seconds >= div:
+      return f"{seconds // div}{unit} ago"
+  return f"{seconds}s ago"
+
+
+class UpdateReason(Enum):
+  ACTION = auto()
+  ENV_SWITCH = auto()
+  SCENE_REQUEST = auto()
+
+
+class ViserPlayViewer(BaseViewer):
+  """Interactive Viser-based viewer with playback controls."""
+
+  def __init__(
+    self,
+    env: EnvProtocol,
+    policy: PolicyProtocol,
+    frame_rate: float = 60.0,
+    verbosity: VerbosityLevel = VerbosityLevel.SILENT,
+    viser_server: viser.ViserServer | None = None,
+    checkpoint_manager: CheckpointManager | None = None,
+  ) -> None:
+    super().__init__(env, policy, frame_rate, verbosity)
+    self._ckpt_mgr = checkpoint_manager
+    self._term_overlays: ViserTermOverlays | None = None
+    self._camera_overlays: ViserCameraOverlays | None = None
+    self._debug_overlays: ViserDebugOverlays | None = None
+    self._contact_overlays: ViserContactOverlays | None = None
+    self._sim_lock = Lock()
+    self._camera_update_last_ms: float = 0.0
+    self._debug_queue_last_ms: float = 0.0
+    self._scene_submit_enqueue_last_ms: float = 0.0
+    self._scene_update_last_ms: float = 0.0
+    self._timing_last_log_time: float = 0.0
+    self._external_server = viser_server is not None
+    self._server = viser_server or viser.ViserServer(label="mjlab")
+
+  @override
+  def setup(self) -> None:
+    """Setup the viewer resources."""
+    sim = self.env.unwrapped.sim
+    assert isinstance(sim, Simulation)
+
+    self._threadpool = ThreadPoolExecutor(max_workers=1)
+    self._counter = 0
+    self._pending_update_reasons: set[UpdateReason] = set()
+
+    # Create MjlabViserScene for all 3D visualization (with debug visualization enabled).
+    self._scene = MjlabViserScene(
+      server=self._server,
+      mj_model=sim.mj_model,
+      num_envs=self.env.num_envs,
+      sim_model=sim.model,
+      expanded_fields=sim.expanded_fields,
+    )
+
+    self._scene.env_idx = self.cfg.env_idx
+    self._scene.debug_visualization_enabled = (
+      True  # Enable debug visualization by default
+    )
+
+    # Create tab group.
+    tabs = self._server.gui.add_tab_group()
+
+    # Main tab with simulation controls and display settings.
+    with tabs.add_tab("Controls", icon=viser.Icon.SETTINGS):
+      # Status display.
+      with self._server.gui.add_folder("Info"):
+        self._status_html = self._server.gui.add_html("")
+
+      # Simulation controls.
+      with self._server.gui.add_folder("Simulation"):
+        # Play/Pause button.
+        self._pause_button = self._server.gui.add_button(
+          "Play" if self._is_paused else "Pause",
+          icon=viser.Icon.PLAYER_PLAY if self._is_paused else viser.Icon.PLAYER_PAUSE,
+        )
+
+        @self._pause_button.on_click
+        def _(_) -> None:
+          self.request_toggle_pause()
+
+        # Single-step button.
+        self._step_button = self._server.gui.add_button(
+          "Step",
+          icon=viser.Icon.PLAYER_TRACK_NEXT,
+        )
+
+        @self._step_button.on_click
+        def _(_) -> None:
+          self.request_single_step()
+
+        # Reset button.
+        reset_button = self._server.gui.add_button("Reset Environment")
+
+        @reset_button.on_click
+        def _(_) -> None:
+          self.request_reset()
+
+        # Speed controls.
+        speed_buttons = self._server.gui.add_button_group(
+          "Speed",
+          options=["Slower", "1x", "Faster"],
+        )
+
+        @speed_buttons.on_click
+        def _(event) -> None:
+          if event.target.value == "Slower":
+            self.request_speed_down()
+          elif event.target.value == "1x":
+            self.request_reset_speed()
+          else:
+            self.request_speed_up()
+
+      # Let command terms create their own GUI controls.
+      env = self.env.unwrapped
+      if env.command_manager.active_terms:
+        with self._server.gui.add_folder("Commands"):
+          env.command_manager.create_gui(
+            self._server,
+            lambda: self._scene.env_idx,
+            on_change=self._scene.request_update,
+            request_action=self.request_action,
+          )
+
+      # Add standard visualization options from MjlabViserScene.
+      def _debug_viz_extra() -> None:
+        env.command_manager.create_debug_vis_gui(
+          self._server, on_change=self._scene.request_update
+        )
+        self._create_sensor_debug_vis_gui()
+        self._create_reward_debug_vis_gui()
+
+      with self._server.gui.add_folder("Scene"):
+        self._scene.create_scene_gui(
+          camera_distance=self.cfg.distance,
+          camera_azimuth=self.cfg.azimuth,
+          camera_elevation=self.cfg.elevation,
+          debug_viz_extra_gui=_debug_viz_extra,
+        )
+
+      self._camera_overlays = ViserCameraOverlays(self._server, self.env, sim.mj_model)
+      if self._camera_overlays.has_cameras:
+        with self._server.gui.add_folder("Camera Feeds"):
+          self._camera_overlays.setup_controls()
+
+    self._prev_env_idx = self._scene.env_idx
+
+    # Visualization tab (overlay controls: contacts, forces, inertia, etc.).
+    with tabs.add_tab("Visualization", icon=viser.Icon.EYE):
+      self._scene.create_overlay_gui()
+
+    self._term_overlays = ViserTermOverlays(
+      self._server,
+      self.env,
+      self._scene,
+      self.frame_time,
+      reward_bar_max_terms=self.cfg.reward_bar_max_terms,
+    )
+    self._term_overlays.setup_tabs(tabs)
+    self._debug_overlays = ViserDebugOverlays(self.env, self._scene)
+    self._contact_overlays = ViserContactOverlays(self._scene)
+
+    # Groups tab (geom/site/joint/tendon/actuator visibility).
+    with tabs.add_tab("Groups", icon=viser.Icon.LAYERS_INTERSECT):
+      self._scene.create_groups_gui()
+
+    # Checkpoints tab (optional, when checkpoint_manager is provided).
+    if self._ckpt_mgr is not None:
+      is_wandb = self._ckpt_mgr.run_url is not None
+      with tabs.add_tab("Checkpoints", icon=viser.Icon.DATABASE):
+        if is_wandb:
+          url = self._ckpt_mgr.run_url
+          self._server.gui.add_html(
+            '<div style="font-size:0.85em;line-height:1.25;'
+            'padding:0 1em 0.5em 1em;">'
+            "<strong>Source:</strong> W&B<br/>"
+            f"<strong>Run:</strong>"
+            f" {self._ckpt_mgr.run_name}<br/>"
+            f"<strong>Status:</strong>"
+            f" {self._ckpt_mgr.run_status}<br/>"
+            f'<a href="{url}" target="_blank"'
+            f' style="color:#3b82f6;">'
+            f"Open in W&B</a>"
+            "</div>"
+          )
+        else:
+          self._server.gui.add_html(
+            '<div style="font-size:0.85em;line-height:1.25;'
+            'padding:0 1em 0.5em 1em;">'
+            "<strong>Source:</strong> Local"
+            "</div>"
+          )
+
+        self._ckpt_dropdown = self._server.gui.add_dropdown(
+          "Checkpoint",
+          options=[self._ckpt_mgr.current_name],
+          initial_value=self._ckpt_mgr.current_name,
+        )
+        self._ckpt_user_event = Event()
+        self._ckpt_user_event.set()
+
+        @self._ckpt_dropdown.on_update
+        def _(_) -> None:
+          if self._ckpt_user_event.is_set():
+            self._actions.append((ViewerAction.FETCH_CHECKPOINT, "selected"))
+
+        ckpt_buttons = self._server.gui.add_button_group(
+          "",
+          options=["Sync", "Use Latest"],
+        )
+
+        @ckpt_buttons.on_click
+        def _(event) -> None:
+          if event.target.value == "Sync":
+            self._actions.append((ViewerAction.FETCH_CHECKPOINT, "refresh"))
+          else:
+            self._actions.append((ViewerAction.FETCH_CHECKPOINT, "latest"))
+
+      # Populate the dropdown on startup.
+      self._actions.append((ViewerAction.FETCH_CHECKPOINT, "refresh"))
+
+  @override
+  def _handle_custom_action(
+    self,
+    action: ViewerAction,
+    payload: Optional[Any],
+  ) -> bool:
+    if isinstance(payload, dict) and payload.get("type") == "gui_reset":
+      self._handle_gui_reset(payload.get("all_envs", False))
+      return True
+    if action != ViewerAction.FETCH_CHECKPOINT:
+      return False
+    if self._ckpt_mgr is None:
+      return True
+
+    if payload in ("refresh", "latest"):
+      entries = self._ckpt_mgr.fetch_available()
+      labels = [f"{n}  ({t})" if t else n for n, t in entries]
+      self._ckpt_user_event.clear()
+      self._ckpt_dropdown.options = labels
+      cur = next(
+        (lbl for lbl in labels if lbl.startswith(self._ckpt_mgr.current_name)),
+        self._ckpt_mgr.current_name,
+      )
+      self._ckpt_dropdown.value = cur
+      self._ckpt_user_event.set()
+      if payload == "refresh" or not entries:
+        return True
+      # "latest" -- select the last entry.
+      name = entries[-1][0]
+    else:
+      # "selected" -- extract name from dropdown label.
+      name = self._ckpt_dropdown.value.split("  (")[0]
+
+    if name != self._ckpt_mgr.current_name:
+      print(f"[INFO]: Loading {name}...")
+      self.policy = self._ckpt_mgr.load_checkpoint(name)
+      self._ckpt_mgr.current_name = name
+      self._ckpt_updating = True
+      cur = next(
+        (lbl for lbl in self._ckpt_dropdown.options if lbl.startswith(name)),
+        name,
+      )
+      self._ckpt_dropdown.value = cur
+      self._ckpt_user_event.set()
+      self.reset_environment()
+      print(f"[INFO]: Loaded {name}")
+    return True
+
+  def _handle_gui_reset(self, all_envs: bool) -> None:
+    """Reset environment(s) and apply GUI-selected command state."""
+    env = self.env.unwrapped
+    if all_envs:
+      env_ids = torch.arange(env.num_envs, dtype=torch.int64, device=env.device)
+    else:
+      env_ids = torch.tensor(
+        [self._scene.env_idx], dtype=torch.int64, device=env.device
+      )
+
+    with self._sim_lock:
+      env.reset(env_ids=env_ids)
+      if env.command_manager.apply_gui_reset(env_ids):
+        env.scene.write_data_to_sim()
+        env.sim.forward()
+        env.sim.sense()
+
+    self._pending_update_reasons.add(UpdateReason.ACTION)
+    self._sync_ui_state()
+
+  @override
+  def _process_actions(self) -> None:
+    """Process queued actions and sync UI state."""
+    had_actions = bool(self._actions)
+    super()._process_actions()
+    if had_actions:
+      self._pending_update_reasons.add(UpdateReason.ACTION)
+      self._sync_ui_state()
+
+  def _sync_ui_state(self) -> None:
+    """Sync UI elements to current state after action processing."""
+    self._pause_button.label = "Play" if self._is_paused else "Pause"
+    self._pause_button.icon = (
+      viser.Icon.PLAYER_PLAY if self._is_paused else viser.Icon.PLAYER_PAUSE
+    )
+    self._update_status_display()
+    self.env.unwrapped.command_manager.on_viewer_pause(self._is_paused)
+
+  def _update_env_dependent_plots(self) -> None:
+    """Refresh reward/metric plots and histories for the selected environment."""
+    if self._scene.env_idx != self._prev_env_idx:
+      self._prev_env_idx = self._scene.env_idx
+      self._pending_update_reasons.add(UpdateReason.ENV_SWITCH)
+      if self._term_overlays:
+        self._term_overlays.on_env_switch()
+      if self._debug_overlays:
+        self._debug_overlays.on_env_switch()
+      if self._contact_overlays:
+        self._contact_overlays.on_env_switch()
+
+    if self._term_overlays:
+      self._term_overlays.update(self._is_paused)
+
+  def _update_camera_feeds(self, sim: Simulation, has_pending_updates: bool) -> None:
+    """Push camera sensor frames to GUI when needed."""
+    t0 = time.perf_counter()
+    if self._camera_overlays and self._should_update_cameras(
+      self._is_paused, has_pending_updates
+    ):
+      self._camera_overlays.update(
+        sim.data, self._scene.env_idx, self._scene._scene_offset
+      )
+    self._camera_update_last_ms = (time.perf_counter() - t0) * 1000.0
+
+  def _create_sensor_debug_vis_gui(self) -> None:
+    """Add per-sensor debug visualization checkboxes."""
+    env = self.env.unwrapped
+    vis_sensors = [
+      s
+      for s in env.scene.sensors.values()
+      if isinstance(s, RayCastSensor) and s.cfg.debug_vis
+    ]
+    if not vis_sensors:
+      return
+    for sensor in vis_sensors:
+      cb = self._server.gui.add_checkbox(
+        sensor.cfg.name,
+        initial_value=sensor._debug_vis_enabled,
+      )
+
+      def _on_update(_ev, _s=sensor, _cb=cb) -> None:
+        _s._debug_vis_enabled = _cb.value
+        self._scene.needs_update = True
+
+      cb.on_update(_on_update)
+
+  def _create_reward_debug_vis_gui(self) -> None:
+    """Add per-reward debug visualization checkboxes."""
+    env = self.env.unwrapped
+    for name, func in env.reward_manager.get_visualizable_terms():
+      cb = self._server.gui.add_checkbox(
+        name,
+        initial_value=func._debug_vis_enabled,
+      )
+
+      def _on_update(_ev, _f=func, _cb=cb) -> None:
+        _f._debug_vis_enabled = _cb.value
+        self._scene.request_update()
+
+      cb.on_update(_on_update)
+
+  def _queue_debug_visualizers(self) -> None:
+    """Queue environment-specific debug draw calls into the scene.
+
+    Acquires ``_sim_lock`` so the clear+requeue is atomic with respect
+    to the background thread that reads the queues in ``scene.update``.
+    """
+    t0 = time.perf_counter()
+    if self._debug_overlays:
+      with self._sim_lock:
+        self._debug_overlays.queue()
+    self._debug_queue_last_ms = (time.perf_counter() - t0) * 1000.0
+
+  def _submit_scene_update_if_needed(
+    self, sim: Simulation, has_pending_updates: bool
+  ) -> None:
+    """Submit a scene sync job when the update policy allows it."""
+    t_enqueue_start = time.perf_counter()
+    if self._scene.needs_update:
+      self._pending_update_reasons.add(UpdateReason.SCENE_REQUEST)
+
+    if not self._should_submit_scene_update(
+      self._counter, self._is_paused, has_pending_updates
+    ):
+      self._scene_submit_enqueue_last_ms = 0.0
+      return
+
+    def update_scene() -> None:
+      with self._sim_lock:
+        t0 = time.perf_counter()
+        with self._server.atomic():
+          self._scene.update(sim.data)
+          self._server.flush()
+        self._scene_update_last_ms = (time.perf_counter() - t0) * 1000.0
+
+    self._threadpool.submit(update_scene)
+    self._scene_submit_enqueue_last_ms = (
+      time.perf_counter() - t_enqueue_start
+    ) * 1000.0
+    self._pending_update_reasons.clear()
+    self._scene.needs_update = False
+
+  def _maybe_log_debug_timings(self) -> None:
+    """Log lightweight Viser pipeline timing in debug mode."""
+    if self.verbosity < VerbosityLevel.DEBUG:
+      return
+    now = time.time()
+    if now - self._timing_last_log_time < 1.0:
+      return
+    self._timing_last_log_time = now
+    self.log(
+      (
+        "[DEBUG] Viser timings: "
+        f"camera={self._camera_update_last_ms:.2f}ms, "
+        f"debug={self._debug_queue_last_ms:.2f}ms, "
+        f"submit_enqueue={self._scene_submit_enqueue_last_ms:.2f}ms, "
+        f"scene_update={self._scene_update_last_ms:.2f}ms"
+      ),
+      VerbosityLevel.DEBUG,
+    )
+
+  @staticmethod
+  def _should_update_cameras(paused: bool, has_pending_updates: bool) -> bool:
+    """Camera feeds update continuously while running and on-demand while paused."""
+    return (not paused) or has_pending_updates
+
+  @staticmethod
+  def _should_submit_scene_update(
+    counter: int, paused: bool, has_pending_updates: bool
+  ) -> bool:
+    """Scene submits at 30Hz (every other 60Hz tick) with pause-aware gating."""
+    if counter % 2 != 0:
+      return False
+    if paused and not has_pending_updates:
+      return False
+    return True
+
+  @override
+  def sync_env_to_viewer(self) -> None:
+    """Synchronize environment state to viewer."""
+    sim = self.env.unwrapped.sim
+    assert isinstance(sim, Simulation)
+    self._scene.paused = self._is_paused
+    self._counter += 1
+    if self._counter % 10 == 0:
+      self._update_status_display()
+    self._update_env_dependent_plots()
+    has_pending_updates = bool(self._pending_update_reasons) or self._scene.needs_update
+    self._update_camera_feeds(sim, has_pending_updates)
+    # Queue debug visualizers only when a scene update will actually be
+    # submitted.  Clearing the queues on skipped ticks creates a race
+    # with the background thread that causes debug overlays to blink.
+    will_submit = self._should_submit_scene_update(
+      self._counter, self._is_paused, has_pending_updates
+    )
+    if will_submit:
+      self._queue_debug_visualizers()
+    self._submit_scene_update_if_needed(sim, has_pending_updates)
+    self._maybe_log_debug_timings()
+
+  @override
+  def sync_viewer_to_env(self) -> None:
+    """Synchronize viewer state to environment (e.g., perturbations)."""
+    pass
+
+  @override
+  def reset_environment(self) -> None:
+    """Extend BaseViewer.reset_environment to clear reward and metrics histories."""
+    with self._sim_lock:
+      super().reset_environment()
+    if self._term_overlays:
+      self._term_overlays.clear_histories()
+
+  @override
+  def close(self) -> None:
+    """Close the viewer and cleanup resources."""
+    if self._term_overlays:
+      self._term_overlays.cleanup()
+    if self._camera_overlays:
+      self._camera_overlays.cleanup()
+    self._threadpool.shutdown(wait=True)
+    if not self._external_server:
+      self._server.stop()
+
+  @override
+  def is_running(self) -> bool:
+    """Check if viewer is running."""
+    return True  # Viser runs until process is killed.
+
+  def _update_status_display(self) -> None:
+    """Update the HTML status display."""
+    status = self.get_status()
+    actual_rt = status.actual_realtime
+    rt_display = f"{actual_rt:.2f}x" if actual_rt > 0 else "—"
+    capped = ' <span style="color:#e74c3c;">[CAPPED]</span>' if status.capped else ""
+    error_line = ""
+    if status.last_error:
+      # Show last line of traceback to avoid flooding the panel.
+      first_line = status.last_error.strip().splitlines()[-1]
+      error_line = (
+        f'<br/><span style="color:#e74c3c;"><strong>Error:</strong> {first_line}</span>'
+      )
+    self._status_html.content = f"""
+      <div style="font-size: 0.85em; line-height: 1.25; padding: 0 1em 0.5em 1em;">
+        <strong>Status:</strong> {"Paused" if status.paused else "Running"}{capped}<br/>
+        <strong>Steps:</strong> {status.step_count}<br/>
+        <strong>Speed:</strong> {status.speed_label}<br/>
+        <strong>Target RT:</strong> {status.target_realtime:.2f}x<br/>
+        <strong>Actual RT:</strong> {rt_display} ({status.smoothed_fps:.0f} FPS){error_line}
+      </div>
+      """
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000..08dab29
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,209 @@
+"""Shared test fixtures and utilities."""
+
+import os
+from pathlib import Path
+
+import mujoco
+import pytest
+import torch
+import warp as wp
+
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.scene import Scene, SceneCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+
+@pytest.fixture(scope="session", autouse=True)
+def configure_test_environment():
+  """Configure test environment settings automatically for all tests."""
+  wp.config.quiet = True
+
+
+def get_test_device() -> str:
+  """Get device for testing, preferring CUDA if available.
+
+  Can be overridden with FORCE_CPU=1 environment variable to test
+  CPU-only behavior on GPU machines.
+  """
+  if os.environ.get("FORCE_CPU") == "1":
+    return "cpu"
+  return "cuda" if torch.cuda.is_available() else "cpu"
+
+
+@pytest.fixture
+def fixtures_dir() -> Path:
+  """Path to test fixtures directory."""
+  return Path(__file__).parent / "fixtures"
+
+
+def load_fixture_xml(fixture_name: str) -> str:
+  """Load XML content from fixture file.
+
+  Args:
+    fixture_name: Name of the fixture file (without .xml extension) or full path.
+
+  Returns:
+    XML content as string.
+  """
+  fixtures_path = Path(__file__).parent / "fixtures"
+  if not fixture_name.endswith(".xml"):
+    fixture_name = f"{fixture_name}.xml"
+  fixture_file = fixtures_path / fixture_name
+  return fixture_file.read_text()
+
+
+def create_entity_with_actuator(xml_string: str, actuator_cfg):
+  """Create entity with actuator from XML string.
+
+  Args:
+    xml_string: MuJoCo XML model string.
+    actuator_cfg: Actuator configuration.
+
+  Returns:
+    Entity instance.
+  """
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(xml_string),
+    articulation=EntityArticulationInfoCfg(actuators=(actuator_cfg,)),
+  )
+  return Entity(cfg)
+
+
+def create_entity_from_fixture(fixture_name: str, actuator_cfg=None):
+  """Create entity from fixture file.
+
+  Args:
+    fixture_name: Name of the fixture file (without .xml extension).
+    actuator_cfg: Optional actuator configuration.
+
+  Returns:
+    Entity instance.
+  """
+  xml_string = load_fixture_xml(fixture_name)
+  if actuator_cfg is not None:
+    return create_entity_with_actuator(xml_string, actuator_cfg)
+  cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(xml_string))
+  return Entity(cfg)
+
+
+def initialize_entity(entity: Entity, device: str, num_envs: int = 1):
+  """Initialize entity with simulation.
+
+  Args:
+    entity: Entity to initialize.
+    device: Device to use ("cpu" or "cuda").
+    num_envs: Number of environments.
+
+  Returns:
+    Tuple of (entity, simulation).
+  """
+  model = entity.compile()
+  sim_cfg = SimulationCfg()
+  sim = Simulation(num_envs=num_envs, cfg=sim_cfg, model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+  return entity, sim
+
+
+def make_scene_and_sim(
+  device: str,
+  xml: str | dict[str, str],
+  sensors: tuple,
+  num_envs: int = 1,
+  sim_cfg: SimulationCfg | None = None,
+) -> tuple[Scene, Simulation]:
+  """Create a scene and simulation from inline XML with sensors wired up.
+
+  ``xml`` may be a single XML string (registered as the ``robot`` entity) or a
+  mapping of entity name to XML string for multi-entity scenes.
+  """
+  xml_by_entity = {"robot": xml} if isinstance(xml, str) else xml
+  entities = {
+    name: EntityCfg(spec_fn=lambda s=s: mujoco.MjSpec.from_string(s))
+    for name, s in xml_by_entity.items()
+  }
+  scene_cfg = SceneCfg(
+    num_envs=num_envs,
+    env_spacing=5.0,
+    entities=entities,
+    sensors=sensors,
+  )
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  if sim_cfg is None:
+    sim_cfg = SimulationCfg(njmax=20)
+  sim = Simulation(num_envs=num_envs, cfg=sim_cfg, model=model, device=device)
+  scene.initialize(sim.mj_model, sim.model, sim.data)
+  if scene.sensor_context is not None:
+    sim.set_sensor_context(scene.sensor_context)
+  return scene, sim
+
+
+# =============================================================================
+# XML Fixture Loaders
+# =============================================================================
+
+
+@pytest.fixture
+def fixed_base_box_xml() -> str:
+  """Load fixed base box XML fixture."""
+  return load_fixture_xml("fixed_base_box")
+
+
+@pytest.fixture
+def floating_base_box_xml() -> str:
+  """Load floating base box XML fixture."""
+  return load_fixture_xml("floating_base_box")
+
+
+@pytest.fixture
+def fixed_base_articulated_xml() -> str:
+  """Load fixed base articulated robot XML fixture."""
+  return load_fixture_xml("fixed_base_articulated")
+
+
+@pytest.fixture
+def floating_base_articulated_xml() -> str:
+  """Load floating base articulated robot XML fixture."""
+  return load_fixture_xml("floating_base_articulated")
+
+
+@pytest.fixture
+def biped_xml() -> str:
+  """Load biped robot XML fixture with ground plane."""
+  return load_fixture_xml("biped")
+
+
+@pytest.fixture
+def robot_with_floor_xml() -> str:
+  """XML for a floating body above a ground plane."""
+  return """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1" pos="0 0 0"/>
+        <body name="base" pos="0 0 2">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="5.0"/>
+          <site name="base_site" pos="0 0 -0.1"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+
+@pytest.fixture
+def falling_box_xml() -> str:
+  """XML for a box that can fall onto a ground plane."""
+  return """
+    <mujoco>
+      <worldbody>
+        <body name="ground" pos="0 0 0">
+          <geom name="ground_geom" type="plane" size="5 5 0.1" rgba="0.5 0.5 0.5 1"/>
+        </body>
+        <body name="box" pos="0 0 0.5">
+          <freejoint name="box_joint"/>
+          <geom name="box_geom" type="box" size="0.1 0.1 0.1" rgba="0.8 0.3 0.3 1"
+            mass="1.0"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
diff --git a/tests/fixtures/biped.xml b/tests/fixtures/biped.xml
new file mode 100644
index 0000000..ff29357
--- /dev/null
+++ b/tests/fixtures/biped.xml
@@ -0,0 +1,19 @@
+<mujoco>
+  <worldbody>
+    <body name="ground" pos="0 0 0">
+      <geom name="ground_geom" type="plane" size="5 5 0.1" rgba="0.5 0.5 0.5 1"/>
+    </body>
+    <body name="base" pos="0 0 0.5">
+      <freejoint name="base_joint"/>
+      <geom name="torso_geom" type="box" size="0.15 0.1 0.2" mass="5.0"/>
+      <body name="left_foot" pos="0.1 0 -0.25">
+        <joint name="left_ankle" type="hinge" axis="0 1 0" range="-0.5 0.5"/>
+        <geom name="left_foot_geom" type="box" size="0.05 0.08 0.02" mass="0.2"/>
+      </body>
+      <body name="right_foot" pos="-0.1 0 -0.25">
+        <joint name="right_ankle" type="hinge" axis="0 1 0" range="-0.5 0.5"/>
+        <geom name="right_foot_geom" type="box" size="0.05 0.08 0.02" mass="0.2"/>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
diff --git a/tests/fixtures/fixed_base_articulated.xml b/tests/fixtures/fixed_base_articulated.xml
new file mode 100644
index 0000000..46b559e
--- /dev/null
+++ b/tests/fixtures/fixed_base_articulated.xml
@@ -0,0 +1,15 @@
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 0.5">
+      <geom name="base_geom" type="cylinder" size="0.1 0.05" mass="5.0"/>
+      <body name="link1" pos="0 0 0.1">
+        <joint name="joint1" type="hinge" axis="0 0 1" range="-3.14 3.14"/>
+        <geom name="link1_geom" type="box" size="0.05 0.05 0.2" mass="1.0"/>
+        <body name="link2" pos="0 0 0.4">
+          <joint name="joint2" type="hinge" axis="0 1 0" range="-1.57 1.57"/>
+          <geom name="link2_geom" type="box" size="0.05 0.05 0.15" mass="0.5"/>
+        </body>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
diff --git a/tests/fixtures/fixed_base_box.xml b/tests/fixtures/fixed_base_box.xml
new file mode 100644
index 0000000..83f7b9a
--- /dev/null
+++ b/tests/fixtures/fixed_base_box.xml
@@ -0,0 +1,7 @@
+<mujoco>
+  <worldbody>
+    <body name="object" pos="0 0 0.5">
+      <geom name="object_geom" type="box" size="0.1 0.1 0.1" rgba="0.8 0.3 0.3 1"/>
+    </body>
+  </worldbody>
+</mujoco>
diff --git a/tests/fixtures/floating_base_articulated.xml b/tests/fixtures/floating_base_articulated.xml
new file mode 100644
index 0000000..4604348
--- /dev/null
+++ b/tests/fixtures/floating_base_articulated.xml
@@ -0,0 +1,20 @@
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="1.0"/>
+      <body name="link1" pos="0 0 0">
+        <joint name="joint1" type="hinge" axis="0 0 1" range="-1.57 1.57"/>
+        <geom name="link1_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+        <site name="site1" pos="0 0 0"/>
+      </body>
+      <body name="link2" pos="0 0 0">
+        <joint name="joint2" type="hinge" axis="0 0 1" range="-1.57 1.57"/>
+        <geom name="link2_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+      </body>
+    </body>
+  </worldbody>
+  <sensor>
+    <jointpos name="joint1_pos" joint="joint1"/>
+  </sensor>
+</mujoco>
diff --git a/tests/fixtures/floating_base_box.xml b/tests/fixtures/floating_base_box.xml
new file mode 100644
index 0000000..b413029
--- /dev/null
+++ b/tests/fixtures/floating_base_box.xml
@@ -0,0 +1,8 @@
+<mujoco>
+  <worldbody>
+    <body name="object" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="object_geom" type="box" size="0.1 0.1 0.1" rgba="0.3 0.3 0.8 1" mass="0.1"/>
+    </body>
+  </worldbody>
+</mujoco>
diff --git a/tests/fixtures/quadcopter.xml b/tests/fixtures/quadcopter.xml
new file mode 100644
index 0000000..640856e
--- /dev/null
+++ b/tests/fixtures/quadcopter.xml
@@ -0,0 +1,43 @@
+<mujoco model="quadcopter">
+  <compiler angle="radian" autolimits="true"/>
+
+  <option timestep="0.002" integrator="implicitfast" gravity="0 0 -9.81"/>
+
+  <default>
+    <geom rgba="0.5 0.5 0.5 1"/>
+    <site size="0.01" rgba="1 0 0 1"/>
+  </default>
+
+  <worldbody>
+    <light pos="0 0 3" dir="0 0 -1" diffuse="0.8 0.8 0.8"/>
+    <geom type="plane" size="5 5 0.1" rgba="0.9 0.9 0.9 1"/>
+
+    <body name="base" pos="0 0 0.5">
+      <freejoint name="root"/>
+      <inertial pos="0 0 0" mass="1.0" diaginertia="0.01 0.01 0.02"/>
+
+      <!-- Central body -->
+      <geom type="box" size="0.1 0.1 0.02" rgba="0.3 0.3 0.8 1"/>
+
+      <!-- Rotor sites at corners -->
+      <site name="rotor_fl" pos="0.1 0.1 0"/>
+      <site name="rotor_fr" pos="0.1 -0.1 0"/>
+      <site name="rotor_rl" pos="-0.1 0.1 0"/>
+      <site name="rotor_rr" pos="-0.1 -0.1 0"/>
+
+      <!-- Visual rotor geoms (non-collision) -->
+      <geom name="rotor_fl_vis" type="cylinder" size="0.05 0.005" pos="0.1 0.1 0" rgba="1 0 0 0.5" contype="0" conaffinity="0"/>
+      <geom name="rotor_fr_vis" type="cylinder" size="0.05 0.005" pos="0.1 -0.1 0" rgba="1 0 0 0.5" contype="0" conaffinity="0"/>
+      <geom name="rotor_rl_vis" type="cylinder" size="0.05 0.005" pos="-0.1 0.1 0" rgba="1 0 0 0.5" contype="0" conaffinity="0"/>
+      <geom name="rotor_rr_vis" type="cylinder" size="0.05 0.005" pos="-0.1 -0.1 0" rgba="1 0 0 0.5" contype="0" conaffinity="0"/>
+    </body>
+  </worldbody>
+
+  <actuator>
+    <!-- Site actuators applying vertical thrust forces -->
+    <motor name="thrust_fl" site="rotor_fl" gear="0 0 1 0 0 0" ctrlrange="0 20"/>
+    <motor name="thrust_fr" site="rotor_fr" gear="0 0 1 0 0 0" ctrlrange="0 20"/>
+    <motor name="thrust_rl" site="rotor_rl" gear="0 0 1 0 0 0" ctrlrange="0 20"/>
+    <motor name="thrust_rr" site="rotor_rr" gear="0 0 1 0 0 0" ctrlrange="0 20"/>
+  </actuator>
+</mujoco>
diff --git a/tests/fixtures/tendon_finger.xml b/tests/fixtures/tendon_finger.xml
new file mode 100644
index 0000000..c041535
--- /dev/null
+++ b/tests/fixtures/tendon_finger.xml
@@ -0,0 +1,43 @@
+<mujoco model="tendon_finger">
+  <compiler angle="radian" autolimits="true"/>
+
+  <default>
+    <geom type="capsule" size="0.01" rgba="0.8 0.6 0.4 1"/>
+    <joint type="hinge" axis="0 1 0" range="-1.57 1.57" damping="0.1"/>
+    <site size="0.005" rgba="1 0 0 1"/>
+  </default>
+
+  <worldbody>
+    <light pos="0 0 1" dir="0 0 -1" diffuse="0.8 0.8 0.8"/>
+    <geom type="plane" size="1 1 0.1" rgba="0.9 0.9 0.9 1"/>
+
+    <body name="proximal_link" pos="0 0 0.5">
+      <joint name="proximal_joint"/>
+      <geom fromto="0 0 0 0 0 0.15" size="0.015"/>
+      <site name="tendon_p1" pos="0 0.02 0.05"/>
+      <site name="tendon_p2" pos="0 0.02 0.15"/>
+
+      <body name="distal_link" pos="0 0 0.15">
+        <joint name="distal_joint"/>
+        <geom fromto="0 0 0 0 0 0.15" size="0.012"/>
+        <site name="tendon_p3" pos="0 0.02 0.05"/>
+        <site name="fingertip" pos="0 0 0.15"/>
+      </body>
+    </body>
+  </worldbody>
+
+  <tendon>
+    <spatial name="finger_tendon" width="0.003" rgba="0.2 0.2 0.8 1">
+      <site site="tendon_p1"/>
+      <site site="tendon_p2"/>
+      <site site="tendon_p3"/>
+    </spatial>
+  </tendon>
+
+  <actuator>
+    <!-- Tendon actuators for testing different control modes -->
+    <position name="tendon_position" tendon="finger_tendon" kp="100" ctrlrange="-0.1 0.1"/>
+    <velocity name="tendon_velocity" tendon="finger_tendon" kv="10" ctrlrange="-1 1"/>
+    <motor name="tendon_effort" tendon="finger_tendon" ctrlrange="-10 10"/>
+  </actuator>
+</mujoco>
diff --git a/tests/smoke_test.py b/tests/smoke_test.py
new file mode 100644
index 0000000..91b4b35
--- /dev/null
+++ b/tests/smoke_test.py
@@ -0,0 +1,36 @@
+"""Smoke test for mjlab package."""
+
+import io
+import sys
+import warnings
+from contextlib import redirect_stderr, redirect_stdout
+
+try:
+  import pytest
+except ModuleNotFoundError:
+  pytest = None  # type: ignore[assignment]
+
+
+@pytest.mark.slow if pytest else lambda f: f
+def test_basic_functionality() -> None:
+  """Test that mjlab can create and close an environment."""
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+  from mjlab.tasks.velocity.config.go1.env_cfgs import unitree_go1_flat_env_cfg
+
+  # Suppress env spam.
+  with warnings.catch_warnings():
+    warnings.simplefilter("ignore")
+    with redirect_stdout(io.StringIO()), redirect_stderr(io.StringIO()):
+      env = ManagerBasedRlEnv(unitree_go1_flat_env_cfg(), device="cpu")
+      assert env.sim.data.time == 0.0
+      env.close()
+
+
+if __name__ == "__main__":
+  try:
+    test_basic_functionality()
+    print("✓ Smoke test passed!")
+    sys.exit(0)
+  except Exception as e:
+    print(f"✗ Smoke test failed: {e}")
+    sys.exit(1)
diff --git a/tests/test_action_manager.py b/tests/test_action_manager.py
new file mode 100644
index 0000000..094188d
--- /dev/null
+++ b/tests/test_action_manager.py
@@ -0,0 +1,118 @@
+"""Tests for action manager functionality."""
+
+from unittest.mock import Mock
+
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.managers.action_manager import ActionManager
+
+
+@pytest.fixture
+def device():
+  """Test device fixture."""
+  return get_test_device()
+
+
+def _make_mock_action_term(action_dim: int):
+  """Create a mock action term factory."""
+
+  def factory(env):
+    term = Mock()
+    term.action_dim = action_dim
+    term.raw_action = torch.zeros(env.num_envs, action_dim, device=env.device)
+    term.process_actions = Mock()
+    term.apply_actions = Mock()
+    term.reset = Mock()
+    return term
+
+  return factory
+
+
+@pytest.fixture
+def mock_env(device):
+  """Create a mock environment for testing."""
+  env = Mock()
+  env.num_envs = 4
+  env.device = device
+  return env
+
+
+@pytest.fixture
+def action_term_cfg():
+  """Create a simple action term config."""
+  cfg = Mock()
+  cfg.build = _make_mock_action_term(action_dim=3)
+  cfg.entity_name = "robot"
+  return cfg
+
+
+def test_action_history_tracking(mock_env, action_term_cfg, device):
+  """Test that action, prev_action, and prev_prev_action track history correctly."""
+  manager = ActionManager({"action": action_term_cfg}, mock_env)
+
+  # Initial state: all zeros.
+  assert torch.all(manager.action == 0.0)
+  assert torch.all(manager.prev_action == 0.0)
+  assert torch.all(manager.prev_prev_action == 0.0)
+
+  # Process actions and verify history shifts correctly.
+  actions = [
+    torch.tensor([[float(i)] * 3] * mock_env.num_envs, device=device)
+    for i in range(1, 5)
+  ]
+
+  manager.process_action(actions[0])
+  assert torch.allclose(manager.action, actions[0])
+  assert torch.all(manager.prev_action == 0.0)
+  assert torch.all(manager.prev_prev_action == 0.0)
+
+  manager.process_action(actions[1])
+  assert torch.allclose(manager.action, actions[1])
+  assert torch.allclose(manager.prev_action, actions[0])
+  assert torch.all(manager.prev_prev_action == 0.0)
+
+  manager.process_action(actions[2])
+  assert torch.allclose(manager.action, actions[2])
+  assert torch.allclose(manager.prev_action, actions[1])
+  assert torch.allclose(manager.prev_prev_action, actions[0])
+
+  manager.process_action(actions[3])
+  assert torch.allclose(manager.action, actions[3])
+  assert torch.allclose(manager.prev_action, actions[2])
+  assert torch.allclose(manager.prev_prev_action, actions[1])
+
+
+def test_action_history_reset(mock_env, action_term_cfg, device):
+  """Test that reset clears action history for all or specific environments."""
+  manager = ActionManager({"action": action_term_cfg}, mock_env)
+
+  # Populate history.
+  actions = [
+    torch.tensor([[float(i)] * 3] * mock_env.num_envs, device=device)
+    for i in range(1, 4)
+  ]
+  for a in actions:
+    manager.process_action(a)
+
+  # Partial reset: only envs 0 and 2.
+  manager.reset(env_ids=torch.tensor([0, 2]))
+
+  # Reset envs should be zeros.
+  for env_id in [0, 2]:
+    assert torch.all(manager.action[env_id] == 0.0)
+    assert torch.all(manager.prev_action[env_id] == 0.0)
+    assert torch.all(manager.prev_prev_action[env_id] == 0.0)
+
+  # Non-reset envs should retain history.
+  for env_id in [1, 3]:
+    assert torch.allclose(manager.action[env_id], actions[2][env_id])
+    assert torch.allclose(manager.prev_action[env_id], actions[1][env_id])
+    assert torch.allclose(manager.prev_prev_action[env_id], actions[0][env_id])
+
+  # Full reset.
+  manager.reset()
+  assert torch.all(manager.action == 0.0)
+  assert torch.all(manager.prev_action == 0.0)
+  assert torch.all(manager.prev_prev_action == 0.0)
diff --git a/tests/test_actions.py b/tests/test_actions.py
new file mode 100644
index 0000000..e6fd04a
--- /dev/null
+++ b/tests/test_actions.py
@@ -0,0 +1,318 @@
+"""Tests for actions."""
+
+from pathlib import Path
+from unittest.mock import Mock
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device, load_fixture_xml
+
+from mjlab.actuator.actuator import TransmissionType
+from mjlab.actuator.builtin_actuator import BuiltinMotorActuatorCfg
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.envs import ManagerBasedRlEnv
+from mjlab.envs.mdp.actions import (
+  JointPositionActionCfg,
+  RelativeJointPositionActionCfg,
+  SiteEffortActionCfg,
+  TendonEffortActionCfg,
+  TendonLengthActionCfg,
+  TendonVelocityActionCfg,
+)
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+@pytest.fixture(scope="module")
+def fixtures_dir():
+  return Path(__file__).parent / "fixtures"
+
+
+@pytest.fixture(scope="module")
+def tendon_finger_entity(fixtures_dir, device):
+  return make_entity(
+    fixtures_dir / "tendon_finger.xml",
+    ("finger_tendon",),
+    TransmissionType.TENDON,
+    device,
+    from_file=True,
+  )
+
+
+@pytest.fixture(scope="module")
+def fixed_base_entity(fixtures_dir, device):
+  return make_entity(
+    fixtures_dir / "fixed_base_articulated.xml",
+    ("joint.*",),
+    TransmissionType.JOINT,
+    device,
+    from_file=True,
+  )
+
+
+@pytest.fixture(scope="module")
+def floating_base_entity(device):
+  return make_entity(
+    load_fixture_xml("floating_base_articulated"),
+    ("joint.*",),
+    TransmissionType.JOINT,
+    device,
+    from_file=False,
+  )
+
+
+def make_entity(xml_or_path, target_expr, transmission_type, device, from_file=False):
+  """Create and initialize entity."""
+
+  def spec_fn():
+    if from_file:
+      return mujoco.MjSpec.from_file(str(xml_or_path))
+    return mujoco.MjSpec.from_string(xml_or_path)
+
+  cfg = EntityCfg(
+    spec_fn=spec_fn,
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinMotorActuatorCfg(
+          target_names_expr=target_expr,
+          transmission_type=transmission_type,
+          effort_limit=10.0,
+        ),
+      )
+    ),
+  )
+  entity = Entity(cfg)
+  model = entity.compile()
+  sim = Simulation(num_envs=4, cfg=SimulationCfg(), model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+  return entity
+
+
+def make_env(entity, name, device):
+  """Create mock environment."""
+  env = Mock(spec=ManagerBasedRlEnv)
+  env.num_envs = 4
+  env.device = device
+  env.scene = {name: entity}
+  return env
+
+
+def test_base_action_applies_scale_and_offset(tendon_finger_entity, device):
+  """BaseAction: processed = raw * scale + offset."""
+  entity = tendon_finger_entity
+  env = make_env(entity, "finger", device)
+
+  cfg = TendonLengthActionCfg(
+    entity_name="finger",
+    actuator_names=("finger_tendon",),
+    scale=2.0,
+    offset=0.5,
+  )
+  action = cfg.build(env)
+
+  raw = torch.tensor([[1.0], [2.0], [3.0], [4.0]], device=device)
+  action.process_actions(raw)
+
+  assert torch.allclose(action._processed_actions, raw * 2.0 + 0.5)
+
+
+def test_base_action_reset_zeros_specific_envs(tendon_finger_entity, device):
+  """BaseAction.reset() zeros raw_action for specified env_ids only."""
+  entity = tendon_finger_entity
+  env = make_env(entity, "finger", device)
+
+  cfg = TendonLengthActionCfg(entity_name="finger", actuator_names=("finger_tendon",))
+  action = cfg.build(env)
+
+  action.process_actions(torch.ones(4, 1, device=device))
+  action.reset(env_ids=torch.tensor([0, 2], device=device))
+
+  assert torch.all(action.raw_action[[0, 2]] == 0.0)
+  assert torch.all(action.raw_action[[1, 3]] == 1.0)
+
+
+@pytest.mark.parametrize(
+  "cfg_cls,target_attr,fixture,target_expr,transmission,entity_name",
+  [
+    # Joints.
+    (
+      JointPositionActionCfg,
+      "joint_pos_target",
+      "floating_base_articulated",
+      ("joint.*",),
+      TransmissionType.JOINT,
+      "robot",
+    ),
+    # Tendons.
+    (
+      TendonLengthActionCfg,
+      "tendon_len_target",
+      "tendon_finger.xml",
+      ("finger_tendon",),
+      TransmissionType.TENDON,
+      "finger",
+    ),
+    (
+      TendonVelocityActionCfg,
+      "tendon_vel_target",
+      "tendon_finger.xml",
+      ("finger_tendon",),
+      TransmissionType.TENDON,
+      "finger",
+    ),
+    (
+      TendonEffortActionCfg,
+      "tendon_effort_target",
+      "tendon_finger.xml",
+      ("finger_tendon",),
+      TransmissionType.TENDON,
+      "finger",
+    ),
+    # Sites.
+    (
+      SiteEffortActionCfg,
+      "site_effort_target",
+      "quadcopter.xml",
+      ("rotor_.*",),
+      TransmissionType.SITE,
+      "drone",
+    ),
+  ],
+)
+def test_action_sets_entity_target(
+  fixtures_dir,
+  device,
+  cfg_cls,
+  target_attr,
+  fixture,
+  target_expr,
+  transmission,
+  entity_name,
+):
+  """Each action type writes to correct entity.data field."""
+  if fixture.endswith(".xml"):
+    entity = make_entity(
+      fixtures_dir / fixture, target_expr, transmission, device, from_file=True
+    )
+  else:
+    entity = make_entity(
+      load_fixture_xml(fixture), target_expr, transmission, device, from_file=False
+    )
+
+  env = make_env(entity, entity_name, device)
+  cfg = cfg_cls(entity_name=entity_name, actuator_names=target_expr)
+  action = cfg.build(env)
+
+  target = torch.arange(4 * action.action_dim, device=device, dtype=torch.float32)
+  target = target.reshape(4, action.action_dim) * 0.1
+
+  action.process_actions(target)
+  action.apply_actions()
+
+  entity_target = getattr(entity.data, target_attr)
+  assert torch.allclose(entity_target, target)
+
+
+def test_base_action_clip(fixed_base_entity, device):
+  """BaseAction: clip clamps only matched actuators; others stay unclipped."""
+  entity = fixed_base_entity
+  env = make_env(entity, "robot", device)
+
+  # Clip only joint1; joint2 should remain unclipped.
+  cfg = JointPositionActionCfg(
+    entity_name="robot",
+    actuator_names=("joint.*",),
+    scale=1.0,
+    use_default_offset=False,
+    clip={"joint1": (-0.5, 0.5)},
+  )
+  action = cfg.build(env)
+
+  # joint1=2.0 should be clipped to 0.5, joint2=2.0 should pass through.
+  raw = torch.tensor([[2.0, 2.0]], device=device).expand(4, -1)
+  action.process_actions(raw)
+
+  assert torch.allclose(
+    action._processed_actions[:, 0], torch.tensor(0.5, device=device)
+  )
+  assert torch.allclose(
+    action._processed_actions[:, 1], torch.tensor(2.0, device=device)
+  )
+
+
+def test_relative_joint_position_zero_action(floating_base_entity, device):
+  """With zero action, targets equal current_pos."""
+  entity = floating_base_entity
+  env = make_env(entity, "robot", device)
+
+  cfg = RelativeJointPositionActionCfg(
+    entity_name="robot", actuator_names=("joint.*",), scale=1.0
+  )
+  action = cfg.build(env)
+
+  current_pos = entity.data.joint_pos[:, action.target_ids].clone()
+
+  action.process_actions(torch.zeros(4, action.action_dim, device=device))
+  action.apply_actions()
+
+  assert torch.allclose(entity.data.joint_pos_target[:, action.target_ids], current_pos)
+
+
+def test_relative_joint_position_nonzero_action(floating_base_entity, device):
+  """With nonzero action, targets shift by action * scale from current."""
+  entity = floating_base_entity
+  env = make_env(entity, "robot", device)
+
+  scale = 0.1
+  cfg = RelativeJointPositionActionCfg(
+    entity_name="robot", actuator_names=("joint.*",), scale=scale
+  )
+  action = cfg.build(env)
+
+  current_pos = entity.data.joint_pos[:, action.target_ids].clone()
+
+  raw = torch.ones(4, action.action_dim, device=device)
+  action.process_actions(raw)
+  action.apply_actions()
+
+  expected = current_pos + raw * scale
+  assert torch.allclose(entity.data.joint_pos_target[:, action.target_ids], expected)
+
+
+def test_relative_joint_position_ignores_encoder_bias(floating_base_entity, device):
+  """Encoder bias must not affect the target: target = current_pos + delta."""
+  entity = floating_base_entity
+  env = make_env(entity, "robot", device)
+
+  cfg = RelativeJointPositionActionCfg(
+    entity_name="robot", actuator_names=("joint.*",), scale=1.0
+  )
+  action = cfg.build(env)
+
+  entity.data.encoder_bias[:, action.target_ids] = 0.05
+
+  current_pos = entity.data.joint_pos[:, action.target_ids].clone()
+  delta = 0.1
+  raw = torch.full((4, action.action_dim), delta, device=device)
+  action.process_actions(raw)
+  action.apply_actions()
+
+  assert torch.allclose(
+    entity.data.joint_pos_target[:, action.target_ids], current_pos + delta
+  )
+
+  # Reset bias so this shared fixture doesn't affect other tests.
+  entity.data.encoder_bias[:, action.target_ids] = 0.0
+
+
+def test_relative_joint_position_offset_raises(floating_base_entity, device):
+  """Setting offset on RelativeJointPositionActionCfg raises ValueError."""
+  with pytest.raises(ValueError, match="offset"):
+    RelativeJointPositionActionCfg(
+      entity_name="robot", actuator_names=("joint.*",), offset=0.5
+    )
diff --git a/tests/test_actuator.py b/tests/test_actuator.py
new file mode 100644
index 0000000..0a65284
--- /dev/null
+++ b/tests/test_actuator.py
@@ -0,0 +1,327 @@
+"""Tests for actuator module."""
+
+import mujoco
+import pytest
+import torch
+from conftest import (
+  create_entity_with_actuator,
+  get_test_device,
+  initialize_entity,
+  load_fixture_xml,
+)
+
+from mjlab.actuator import (
+  BuiltinMotorActuatorCfg,
+  BuiltinPositionActuatorCfg,
+  BuiltinVelocityActuatorCfg,
+  IdealPdActuatorCfg,
+  XmlActuatorCfg,
+)
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+@pytest.fixture(scope="module")
+def robot_xml():
+  return load_fixture_xml("floating_base_articulated")
+
+
+def test_builtin_pd_actuator_compute(device, robot_xml):
+  """BuiltinPositionActuator writes position targets to ctrl."""
+  actuator_cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint.*",), stiffness=50.0, damping=5.0
+  )
+  entity = create_entity_with_actuator(robot_xml, actuator_cfg)
+  entity, sim = initialize_entity(entity, device)
+
+  entity.set_joint_position_target(torch.tensor([[0.5, -0.3]], device=device))
+  entity.write_data_to_sim()
+
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([0.5, -0.3], device=device))
+
+
+def test_ideal_pd_actuator_compute(device, robot_xml):
+  """IdealPdActuator computes torques via explicit PD control."""
+  actuator_cfg = IdealPdActuatorCfg(
+    target_names_expr=("joint.*",), effort_limit=100.0, stiffness=50.0, damping=5.0
+  )
+  entity = create_entity_with_actuator(robot_xml, actuator_cfg)
+  entity, sim = initialize_entity(entity, device)
+
+  entity.write_joint_state_to_sim(
+    position=torch.tensor([[0.0, 0.0]], device=device),
+    velocity=torch.tensor([[0.0, 0.0]], device=device),
+  )
+
+  entity.set_joint_position_target(torch.tensor([[0.1, -0.1]], device=device))
+  entity.set_joint_velocity_target(torch.tensor([[0.0, 0.0]], device=device))
+  entity.set_joint_effort_target(torch.tensor([[0.0, 0.0]], device=device))
+  entity.write_data_to_sim()
+
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([5.0, -5.0], device=device))
+
+
+def test_targets_cleared_on_reset(device, robot_xml):
+  """Entity.reset() zeros all targets."""
+  actuator_cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint.*",), stiffness=50.0, damping=5.0
+  )
+  entity = create_entity_with_actuator(robot_xml, actuator_cfg)
+  entity, sim = initialize_entity(entity, device)
+
+  entity.set_joint_position_target(torch.tensor([[0.5, -0.3]], device=device))
+  entity.write_data_to_sim()
+
+  assert not torch.allclose(
+    entity.data.joint_pos_target, torch.zeros(1, 2, device=device)
+  )
+
+  entity.reset()
+
+  assert torch.allclose(entity.data.joint_pos_target, torch.zeros(1, 2, device=device))
+  assert torch.allclose(entity.data.joint_vel_target, torch.zeros(1, 2, device=device))
+  assert torch.allclose(
+    entity.data.joint_effort_target, torch.zeros(1, 2, device=device)
+  )
+
+
+# ---------------------------------------------------------------------------
+# Internal attach prefix tests (issue #709)
+# ---------------------------------------------------------------------------
+
+
+def _make_arm_spec() -> mujoco.MjSpec:
+  """Helper: single-joint arm with a motor actuator."""
+  spec = mujoco.MjSpec()
+  body = spec.worldbody.add_body(name="link")
+  body.add_joint(name="elbow", type=mujoco.mjtJoint.mjJNT_HINGE)
+  body.add_geom(type=mujoco.mjtGeom.mjGEOM_SPHERE, size=[0.1, 0, 0])
+  act = spec.add_actuator(name="motor_elbow", target="elbow")
+  act.trntype = mujoco.mjtTrn.mjTRN_JOINT
+  act.gainprm[:] = [1] + [0] * 9
+  return spec
+
+
+def _prefixed_entity_spec() -> mujoco.MjSpec:
+  """Entity spec that composes a sub-model via internal attach."""
+  root = mujoco.MjSpec()
+  root.worldbody.add_geom(type=mujoco.mjtGeom.mjGEOM_PLANE, size=[1, 1, 0.01])
+  frame = root.worldbody.add_frame()
+  root.attach(_make_arm_spec(), prefix="arm/", frame=frame)
+  return root
+
+
+def test_builtin_actuator_with_internal_attach_prefix(device):
+  """Builtin actuator resolves joints through internal attach prefix."""
+  cfg = EntityCfg(
+    spec_fn=_prefixed_entity_spec,
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinMotorActuatorCfg(target_names_expr=("elbow",), effort_limit=100.0),
+      )
+    ),
+  )
+  entity = Entity(cfg)
+
+  # User-facing names should be stripped.
+  assert entity.joint_names == ("elbow",)
+
+  entity, _ = initialize_entity(entity, device)
+
+  assert len(entity.actuators) == 1
+  assert entity.actuators[0].target_names == ["elbow"]
+
+
+def test_xml_actuator_with_internal_attach_prefix(device):
+  """XML actuator matches targets through internal attach prefix."""
+  cfg = EntityCfg(
+    spec_fn=_prefixed_entity_spec,
+    articulation=EntityArticulationInfoCfg(
+      actuators=(XmlActuatorCfg(target_names_expr=("elbow",)),)
+    ),
+  )
+  entity = Entity(cfg)
+  entity, sim = initialize_entity(entity, device)
+
+  assert len(entity.actuators) == 1
+  assert entity.actuators[0].target_names == ["elbow"]
+
+
+# ---------------------------------------------------------------------------
+# Armature / frictionloss preservation tests
+# ---------------------------------------------------------------------------
+
+_XML_WITH_JOINT_PROPERTIES = """\
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom type="box" size="0.2 0.2 0.1" mass="1.0"/>
+      <body name="link1">
+        <joint name="joint1" type="hinge" axis="0 0 1"
+               range="-1.57 1.57" armature="0.5" frictionloss="0.3"
+               damping="0.8"/>
+        <geom type="box" size="0.1 0.1 0.1" mass="0.1"/>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+
+def test_xml_armature_frictionloss_preserved_by_default(device):
+  """Builtin actuator preserves XML armature/frictionloss when not set."""
+  cfg = BuiltinMotorActuatorCfg(target_names_expr=("joint1",), effort_limit=100.0)
+  entity = create_entity_with_actuator(_XML_WITH_JOINT_PROPERTIES, cfg)
+  entity, sim = initialize_entity(entity, device)
+
+  m = sim.mj_model
+  dof_id = m.jnt_dofadr[m.joint("joint1").id]
+  assert m.dof_armature[dof_id] == pytest.approx(0.5)
+  assert m.dof_frictionloss[dof_id] == pytest.approx(0.3)
+
+
+def test_explicit_armature_frictionloss_overrides_xml(device):
+  """Explicit values override XML armature/frictionloss."""
+  cfg = BuiltinMotorActuatorCfg(
+    target_names_expr=("joint1",),
+    effort_limit=100.0,
+    armature=1.0,
+    frictionloss=0.7,
+  )
+  entity = create_entity_with_actuator(_XML_WITH_JOINT_PROPERTIES, cfg)
+  entity, sim = initialize_entity(entity, device)
+
+  m = sim.mj_model
+  dof_id = m.jnt_dofadr[m.joint("joint1").id]
+  assert m.dof_armature[dof_id] == pytest.approx(1.0)
+  assert m.dof_frictionloss[dof_id] == pytest.approx(0.7)
+
+
+def test_explicit_zero_overrides_xml(device):
+  """Explicit 0.0 overrides XML values (distinguishes None from 0.0)."""
+  cfg = BuiltinMotorActuatorCfg(
+    target_names_expr=("joint1",),
+    effort_limit=100.0,
+    armature=0.0,
+    frictionloss=0.0,
+  )
+  entity = create_entity_with_actuator(_XML_WITH_JOINT_PROPERTIES, cfg)
+  entity, sim = initialize_entity(entity, device)
+
+  m = sim.mj_model
+  dof_id = m.jnt_dofadr[m.joint("joint1").id]
+  assert m.dof_armature[dof_id] == pytest.approx(0.0)
+  assert m.dof_frictionloss[dof_id] == pytest.approx(0.0)
+
+
+def test_partial_override_preserves_other_field(device):
+  """Setting only armature preserves XML frictionloss, and vice versa."""
+  cfg = BuiltinMotorActuatorCfg(
+    target_names_expr=("joint1",), effort_limit=100.0, armature=1.0
+  )
+  entity = create_entity_with_actuator(_XML_WITH_JOINT_PROPERTIES, cfg)
+  entity, sim = initialize_entity(entity, device)
+
+  m = sim.mj_model
+  dof_id = m.jnt_dofadr[m.joint("joint1").id]
+  assert m.dof_armature[dof_id] == pytest.approx(1.0)
+  assert m.dof_frictionloss[dof_id] == pytest.approx(0.3)
+
+
+@pytest.mark.parametrize(
+  "actuator_cfg",
+  [
+    BuiltinPositionActuatorCfg(
+      target_names_expr=("joint1",), stiffness=50.0, damping=5.0
+    ),
+    BuiltinVelocityActuatorCfg(target_names_expr=("joint1",), damping=5.0),
+    IdealPdActuatorCfg(
+      target_names_expr=("joint1",),
+      stiffness=50.0,
+      damping=5.0,
+      effort_limit=100.0,
+    ),
+  ],
+  ids=["position", "velocity", "ideal_pd"],
+)
+def test_all_actuator_types_preserve_xml_properties(device, actuator_cfg):
+  """All builtin actuator types preserve XML armature/frictionloss."""
+  entity = create_entity_with_actuator(_XML_WITH_JOINT_PROPERTIES, actuator_cfg)
+  entity, sim = initialize_entity(entity, device)
+
+  m = sim.mj_model
+  dof_id = m.jnt_dofadr[m.joint("joint1").id]
+  assert m.dof_armature[dof_id] == pytest.approx(0.5)
+  assert m.dof_frictionloss[dof_id] == pytest.approx(0.3)
+
+
+# ---------------------------------------------------------------------------
+# Viscous damping tests
+# ---------------------------------------------------------------------------
+
+
+def test_viscous_damping_default_preserves_xml(device):
+  """viscous_damping=None preserves XML joint damping (0.8)."""
+  cfg = BuiltinMotorActuatorCfg(target_names_expr=("joint1",), effort_limit=100.0)
+  entity = create_entity_with_actuator(_XML_WITH_JOINT_PROPERTIES, cfg)
+  entity, sim = initialize_entity(entity, device)
+
+  m = sim.mj_model
+  dof_id = m.jnt_dofadr[m.joint("joint1").id]
+  assert m.dof_damping[dof_id] == pytest.approx(0.8)
+
+
+def test_viscous_damping_explicit_overrides_xml(device):
+  """Explicit viscous_damping overrides XML damping."""
+  cfg = BuiltinMotorActuatorCfg(
+    target_names_expr=("joint1",), effort_limit=100.0, viscous_damping=2.5
+  )
+  entity = create_entity_with_actuator(_XML_WITH_JOINT_PROPERTIES, cfg)
+  entity, sim = initialize_entity(entity, device)
+
+  m = sim.mj_model
+  dof_id = m.jnt_dofadr[m.joint("joint1").id]
+  assert m.dof_damping[dof_id] == pytest.approx(2.5)
+
+
+def test_viscous_damping_explicit_zero_overrides_xml(device):
+  """Explicit 0.0 overrides XML damping (distinguishes None from 0.0)."""
+  cfg = BuiltinMotorActuatorCfg(
+    target_names_expr=("joint1",), effort_limit=100.0, viscous_damping=0.0
+  )
+  entity = create_entity_with_actuator(_XML_WITH_JOINT_PROPERTIES, cfg)
+  entity, sim = initialize_entity(entity, device)
+
+  m = sim.mj_model
+  dof_id = m.jnt_dofadr[m.joint("joint1").id]
+  assert m.dof_damping[dof_id] == pytest.approx(0.0)
+
+
+def test_viscous_damping_produces_passive_force(device, robot_xml):
+  """Nonzero viscous_damping produces a dissipative passive force."""
+  damping = 3.0
+  actuator_cfg = BuiltinMotorActuatorCfg(
+    target_names_expr=("joint.*",), effort_limit=100.0, viscous_damping=damping
+  )
+  entity = create_entity_with_actuator(robot_xml, actuator_cfg)
+  entity, sim = initialize_entity(entity, device)
+
+  vel = torch.tensor([[1.0, -2.0]], device=device)
+  entity.write_joint_state_to_sim(
+    position=torch.zeros(1, 2, device=device),
+    velocity=vel,
+  )
+  entity.write_data_to_sim()
+  sim.step()
+
+  qfrc_damper = sim.data.qfrc_damper[0]
+  # f = -b * v
+  assert qfrc_damper[6].item() == pytest.approx(-damping * 1.0, abs=1e-4)
+  assert qfrc_damper[7].item() == pytest.approx(-damping * -2.0, abs=1e-4)
diff --git a/tests/test_actuator_builtin_group.py b/tests/test_actuator_builtin_group.py
new file mode 100644
index 0000000..899598f
--- /dev/null
+++ b/tests/test_actuator_builtin_group.py
@@ -0,0 +1,215 @@
+"""Tests for BuiltinActuatorGroup."""
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device, load_fixture_xml
+
+from mjlab.actuator import (
+  BuiltinMotorActuatorCfg,
+  BuiltinPositionActuatorCfg,
+  IdealPdActuatorCfg,
+)
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+ROBOT_XML = load_fixture_xml("floating_base_articulated")
+
+ROBOT_XML_3JOINT = """
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="1.0"/>
+      <body name="link1" pos="0 0 0">
+        <joint name="joint1" type="hinge" axis="0 0 1" range="-1.57 1.57"/>
+        <geom name="link1_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+      </body>
+      <body name="link2" pos="0 0 0">
+        <joint name="joint2" type="hinge" axis="0 0 1" range="-1.57 1.57"/>
+        <geom name="link2_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+      </body>
+      <body name="link3" pos="0 0 0">
+        <joint name="joint3" type="hinge" axis="0 0 1" range="-1.57 1.57"/>
+        <geom name="link3_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+def create_entity(actuator_cfgs, robot_xml=ROBOT_XML, **kwargs):
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(robot_xml),
+    articulation=EntityArticulationInfoCfg(actuators=actuator_cfgs),
+    **kwargs,
+  )
+  return Entity(cfg)
+
+
+def initialize_entity(entity, device, num_envs=1):
+  model = entity.compile()
+  sim_cfg = SimulationCfg()
+  sim = Simulation(num_envs=num_envs, cfg=sim_cfg, model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+  return entity, sim
+
+
+def test_position_actuator_batched(device):
+  """BuiltinPositionActuator writes position targets via batched path."""
+  actuator_cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint.*",), stiffness=50.0, damping=5.0
+  )
+  entity = create_entity((actuator_cfg,))
+  entity, sim = initialize_entity(entity, device)
+
+  entity.set_joint_position_target(torch.tensor([[0.5, -0.3]], device=device))
+  entity.write_data_to_sim()
+
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([0.5, -0.3], device=device))
+
+
+def test_motor_actuator_batched(device):
+  """BuiltinMotorActuator writes effort targets via batched path."""
+  actuator_cfg = BuiltinMotorActuatorCfg(
+    target_names_expr=("joint.*",), effort_limit=100.0
+  )
+  entity = create_entity((actuator_cfg,))
+  entity, sim = initialize_entity(entity, device)
+
+  entity.set_joint_effort_target(torch.tensor([[10.0, -5.0]], device=device))
+  entity.write_data_to_sim()
+
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([10.0, -5.0], device=device))
+
+
+def test_mixed_builtin_actuators(device):
+  """Multiple builtin actuator types can coexist and all use batched path."""
+  position_cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint1",), stiffness=50.0, damping=5.0
+  )
+  motor_cfg = BuiltinMotorActuatorCfg(target_names_expr=("joint2",), effort_limit=100.0)
+  entity = create_entity((position_cfg, motor_cfg))
+  entity, sim = initialize_entity(entity, device)
+
+  entity.set_joint_position_target(torch.tensor([[0.5, 0.0]], device=device))
+  entity.set_joint_effort_target(torch.tensor([[0.0, -3.0]], device=device))
+  entity.write_data_to_sim()
+
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([0.5, -3.0], device=device))
+
+
+def test_builtin_and_custom_actuators(device):
+  """Builtin actuators use batched path, custom actuators use compute()."""
+  builtin_cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint1",), stiffness=50.0, damping=5.0
+  )
+  custom_cfg = IdealPdActuatorCfg(
+    target_names_expr=("joint2",), effort_limit=100.0, stiffness=50.0, damping=5.0
+  )
+  entity = create_entity((builtin_cfg, custom_cfg))
+  entity, sim = initialize_entity(entity, device)
+
+  entity.write_joint_state_to_sim(
+    position=torch.tensor([[0.0, 0.0]], device=device),
+    velocity=torch.tensor([[0.0, 0.0]], device=device),
+  )
+
+  entity.set_joint_position_target(torch.tensor([[0.5, 0.2]], device=device))
+  entity.set_joint_velocity_target(torch.tensor([[0.0, 0.0]], device=device))
+  entity.set_joint_effort_target(torch.tensor([[0.0, 0.0]], device=device))
+  entity.write_data_to_sim()
+
+  ctrl = sim.data.ctrl[0]
+  # joint1: builtin position -> ctrl = 0.5
+  # joint2: ideal pd -> ctrl = kp * (0.2 - 0.0) = 50.0 * 0.2 = 10.0
+  assert torch.allclose(ctrl, torch.tensor([0.5, 10.0], device=device))
+
+
+def test_builtin_group_mismatched_indices(device):
+  """Controls are written correctly when actuator order differs from joint order."""
+  # Actuators: position on joint2, motor on joint1+joint3.
+  # MuJoCo ctrl order follows declaration: [joint2, joint1, joint3].
+  position_cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint2",), stiffness=50.0, damping=5.0
+  )
+  motor_cfg = BuiltinMotorActuatorCfg(
+    target_names_expr=("joint1", "joint3"), effort_limit=100.0
+  )
+  entity = create_entity((position_cfg, motor_cfg), robot_xml=ROBOT_XML_3JOINT)
+  entity, sim = initialize_entity(entity, device, num_envs=1)
+
+  entity.set_joint_position_target(torch.tensor([[10.0, 20.0, 30.0]], device=device))
+  entity.set_joint_effort_target(torch.tensor([[100.0, 200.0, 300.0]], device=device))
+  entity.write_data_to_sim()
+
+  # ctrl follows declaration order: joint2=20, joint1=100, joint3=300.
+  expected = torch.tensor([20.0, 100.0, 300.0], device=device)
+  assert torch.allclose(sim.data.ctrl[0], expected)
+
+
+def test_sort_actuators(device):
+  """sort_actuators=True reorders ctrl to match joint definition order."""
+  position_cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint2",), stiffness=50.0, damping=5.0
+  )
+  motor_cfg = BuiltinMotorActuatorCfg(
+    target_names_expr=("joint1", "joint3"), effort_limit=100.0
+  )
+  entity = create_entity(
+    (position_cfg, motor_cfg),
+    robot_xml=ROBOT_XML_3JOINT,
+    sort_actuators=True,
+  )
+  entity, sim = initialize_entity(entity, device, num_envs=1)
+
+  entity.set_joint_position_target(torch.tensor([[10.0, 20.0, 30.0]], device=device))
+  entity.set_joint_effort_target(torch.tensor([[100.0, 200.0, 300.0]], device=device))
+  entity.write_data_to_sim()
+
+  # Sorted by joint order: joint1=100, joint2=20, joint3=300.
+  expected = torch.tensor([100.0, 20.0, 300.0], device=device)
+  assert torch.allclose(sim.data.ctrl[0], expected)
+
+
+def test_position_actuator_ctrlrange_matches_forcerange(device):
+  """Commanding to ctrlrange limits produces forces matching forcerange."""
+  actuator_cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint.*",),
+    stiffness=50.0,
+    damping=5.0,
+    effort_limit=100.0,
+  )
+  entity = create_entity((actuator_cfg,), robot_xml=ROBOT_XML_3JOINT)
+  model = entity.compile()
+  sim = Simulation(num_envs=1, cfg=SimulationCfg(), model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+
+  n = model.nu
+  ctrlrange = torch.tensor(model.actuator_ctrlrange, device=device, dtype=torch.float32)
+  forcerange = torch.tensor(
+    model.actuator_forcerange, device=device, dtype=torch.float32
+  )
+  zeros = torch.zeros((1, n), device=device)
+
+  for col, label in [(1, "max"), (0, "min")]:
+    entity.write_joint_state_to_sim(position=zeros, velocity=zeros)
+    entity.set_joint_position_target(ctrlrange[:, col].unsqueeze(0))
+    entity.set_joint_effort_target(zeros)
+    entity.write_data_to_sim()
+    sim.step()
+
+    forces = sim.data.actuator_force[0]
+    assert torch.allclose(forces, forcerange[:, col], rtol=0.05), (
+      f"Forces at ctrl {label} {forces} not within 5% of "
+      f"forcerange {label} {forcerange[:, col]}"
+    )
diff --git a/tests/test_asset_zoo.py b/tests/test_asset_zoo.py
new file mode 100644
index 0000000..6be2647
--- /dev/null
+++ b/tests/test_asset_zoo.py
@@ -0,0 +1,18 @@
+import mujoco
+import pytest
+
+from mjlab.asset_zoo.robots import get_g1_robot_cfg, get_go1_robot_cfg
+from mjlab.entity import Entity
+
+
+@pytest.mark.parametrize(
+  "robot_name,robot_cfg_fn",
+  [
+    ("G1", get_g1_robot_cfg),
+    ("GO1", get_go1_robot_cfg),
+  ],
+)
+def test_robot_compiles_parametrized(robot_name: str, robot_cfg_fn) -> None:
+  """Tests that all robots in the asset zoo compile without errors."""
+  robot_cfg = robot_cfg_fn()
+  assert isinstance(Entity(robot_cfg).compile(), mujoco.MjModel)
diff --git a/tests/test_auto_reset.py b/tests/test_auto_reset.py
new file mode 100644
index 0000000..176c373
--- /dev/null
+++ b/tests/test_auto_reset.py
@@ -0,0 +1,328 @@
+"""Tests for the auto_reset config flag."""
+
+import pytest
+import torch
+from conftest import get_test_device
+from test_command_manager import CounterCommand, CounterCommandCfg
+
+from mjlab.envs import ManagerBasedRlEnv
+from mjlab.managers.event_manager import EventTermCfg
+from mjlab.tasks.cartpole.cartpole_env_cfg import cartpole_balance_env_cfg
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+def _make_cfg(auto_reset: bool):
+  cfg = cartpole_balance_env_cfg()
+  cfg.episode_length_s = 0.5  # 10 steps at dt=0.05
+  cfg.scene.num_envs = 4
+  cfg.auto_reset = auto_reset
+  return cfg
+
+
+def _step_until_done_env(env):
+  """Step with zero actions until at least one env is done. Return step outputs."""
+  for _ in range(env.max_episode_length + 5):
+    action = torch.zeros((env.num_envs, 1), device=env.device)
+    result = env.step(action)
+    terminated, truncated = result[2], result[3]
+    if (terminated | truncated).any():
+      return result
+  pytest.fail("No env terminated within max_episode_length steps")
+
+
+def test_auto_reset_true_resets_done_envs(device):
+  """With auto_reset=True (default), done envs are reset during step."""
+  env = ManagerBasedRlEnv(cfg=_make_cfg(auto_reset=True), device=device)
+  env.reset()
+  _, _, terminated, truncated, _ = _step_until_done_env(env)
+  done = terminated | truncated
+  done_ids = done.nonzero(as_tuple=False).squeeze(-1)
+
+  # Episode counter was reset to 0 for done envs.
+  assert (env.episode_length_buf[done_ids] == 0).all()
+  env.close()
+
+
+def test_auto_reset_false_preserves_terminal_state(device):
+  """With auto_reset=False, done envs are NOT reset and obs is the terminal state."""
+  env = ManagerBasedRlEnv(cfg=_make_cfg(auto_reset=False), device=device)
+  env.reset()
+  obs, _, terminated, truncated, _ = _step_until_done_env(env)
+  done = terminated | truncated
+  done_ids = done.nonzero(as_tuple=False).squeeze(-1)
+
+  # Episode counter was NOT reset (still at max_episode_length).
+  assert (env.episode_length_buf[done_ids] == env.max_episode_length).all()
+
+  # The returned obs must reflect the current (post-decimation terminal) sim
+  # state. Since no reset ran and the sim wasn't touched after step(), a fresh
+  # observation_manager.compute() on the current sim state must match exactly.
+  # This catches regressions where step() might return stale or post-reset obs.
+  env.observation_manager._obs_buffer = None  # bypass cache
+  fresh_obs = env.observation_manager.compute()
+  for group in obs:
+    returned = obs[group]
+    current = fresh_obs[group]
+    assert isinstance(returned, torch.Tensor) and isinstance(current, torch.Tensor)
+    assert torch.equal(returned, current)
+  env.close()
+
+
+def test_auto_reset_false_explicit_reset_works(device):
+  """After auto_reset=False, calling reset(env_ids=...) resets those envs."""
+  env = ManagerBasedRlEnv(cfg=_make_cfg(auto_reset=False), device=device)
+  env.reset()
+  _, _, terminated, truncated, _ = _step_until_done_env(env)
+  done = terminated | truncated
+  done_ids = done.nonzero(as_tuple=False).squeeze(-1)
+
+  # Manually reset done envs.
+  env.reset(env_ids=done_ids)
+  assert (env.episode_length_buf[done_ids] == 0).all()
+
+  # Can continue stepping after manual reset.
+  action = torch.zeros((env.num_envs, 1), device=env.device)
+  obs, reward, _, _, _ = env.step(action)
+  assert obs is not None
+  assert reward is not None
+  env.close()
+
+
+def test_auto_reset_false_requires_manual_reset_before_next_step(device):
+  """Raw env should reject another step until done envs are explicitly reset."""
+  env = ManagerBasedRlEnv(cfg=_make_cfg(auto_reset=False), device=device)
+  env.reset()
+  _step_until_done_env(env)
+
+  action = torch.zeros((env.num_envs, 1), device=env.device)
+  with pytest.raises(RuntimeError, match="must be reset via reset"):
+    env.step(action)
+
+  env.close()
+
+
+def _slice_obs(obs: dict, ids: torch.Tensor) -> dict[str, torch.Tensor]:
+  """Return a new obs dict containing only the rows at ``ids`` (per group)."""
+  return {k: v[ids] for k, v in obs.items() if isinstance(v, torch.Tensor)}
+
+
+def test_auto_reset_false_user_loop_pattern(device):
+  """Example: run your own training loop against an auto_reset=False env.
+
+  The pattern is:
+    1. After step(), derive done_ids from terminated | truncated.
+    2. Slice obs[done_ids] to get the true terminal observation and use it for
+      bootstrap / target computation.
+    3. Call env.reset(env_ids=done_ids) to reset only the done envs.
+    4. Continue stepping with the full batch.
+  """
+  env = ManagerBasedRlEnv(cfg=_make_cfg(auto_reset=False), device=device)
+  obs, _ = env.reset(seed=0)
+  episode_count = torch.zeros(env.num_envs, dtype=torch.long, device=env.device)
+  last_terminal_obs: dict[str, torch.Tensor] | None = None
+
+  action = torch.zeros((env.num_envs, 1), device=env.device)
+  for _ in range((env.max_episode_length + 2) * 3):
+    obs, _, terminated, truncated, _ = env.step(action)
+    done = terminated | truncated
+    if not done.any():
+      continue
+
+    done_ids = done.nonzero(as_tuple=False).squeeze(-1)
+    last_terminal_obs = _slice_obs(obs, done_ids)  # feed this to your critic/replay
+
+    episode_count[done_ids] += 1
+    obs, _ = env.reset(env_ids=done_ids)
+    if (episode_count >= 2).all():
+      break
+
+  assert (episode_count >= 2).all()
+  assert last_terminal_obs is not None
+  env.close()
+
+
+def test_auto_reset_false_obs_differs_from_auto_reset_true(device):
+  """Terminal obs (auto_reset=False) differs from post-reset obs (auto_reset=True)."""
+  # Run with auto_reset=True, capture post-reset obs for done envs.
+  env_on = ManagerBasedRlEnv(cfg=_make_cfg(auto_reset=True), device=device)
+  env_on.reset(seed=42)
+  obs_on, _, _, _, _ = _step_until_done_env(env_on)
+  env_on.close()
+
+  # Run with auto_reset=False with the same seed, capture terminal obs.
+  env_off = ManagerBasedRlEnv(cfg=_make_cfg(auto_reset=False), device=device)
+  env_off.reset(seed=42)
+  obs_off, _, _, _, _ = _step_until_done_env(env_off)
+  env_off.close()
+
+  # The observations should differ: one is post-reset, the other is terminal.
+  for group in obs_on:
+    on_val = obs_on[group]
+    off_val = obs_off[group]
+    assert isinstance(on_val, torch.Tensor) and isinstance(off_val, torch.Tensor)
+    assert not torch.equal(on_val, off_val)
+
+
+def test_partial_reset_leaves_other_envs_obs_buffers_untouched(device):
+  """reset(env_ids=...) must not advance other envs' history/delay buffers."""
+  cfg = _make_cfg(auto_reset=False)
+  cfg.observations["actor"].terms["cart_pos"].history_length = 4
+  cfg.observations["actor"].terms["cart_vel"].delay_min_lag = 2
+  cfg.observations["actor"].terms["cart_vel"].delay_max_lag = 2
+  env = ManagerBasedRlEnv(cfg=cfg, device=device)
+  env.reset()
+  action = torch.zeros((env.num_envs, 1), device=env.device)
+  for _ in range(3):
+    env.step(action)
+
+  om = env.observation_manager
+  hist = om._group_obs_term_history_buffer["actor"]["cart_pos"]
+  delay = om._group_obs_term_delay_buffer["actor"]["cart_vel"]
+  h_before = hist.buffer[0].clone()
+  d_before = delay.peek()[0].clone()
+
+  env.reset(env_ids=torch.tensor([1], dtype=torch.int64, device=env.device))
+
+  # Env 0 was not reset: history window and delayed obs are untouched.
+  assert torch.equal(hist.buffer[0], h_before)
+  assert torch.equal(delay.peek()[0], d_before)
+
+  # Env 1 was reset: history is backfilled with its single post-reset frame.
+  h1 = hist.buffer[1]
+  assert torch.all(h1 == h1[0])
+  assert hist.current_length[1].item() == 1
+  env.close()
+
+
+# Section: parity between auto-reset and the explicit reset() flow.
+
+_COMMAND_T = 7.0
+_INTERVAL_T = 5.0
+_MARKER_VEL = 37.0
+
+
+def _noop_event(env, env_ids) -> None:
+  del env, env_ids
+
+
+def _write_marker_velocity(env, env_ids) -> None:
+  """Overwrite joint velocities with a recognizable marker value."""
+  asset = env.scene["cartpole"]
+  if env_ids is None:
+    env_ids = torch.arange(env.num_envs, device=env.device)
+  joint_pos = asset.data.joint_pos[env_ids]
+  joint_vel = torch.full_like(asset.data.joint_vel[env_ids], _MARKER_VEL)
+  asset.write_joint_state_to_sim(joint_pos, joint_vel, env_ids=env_ids)
+
+
+def _make_parity_cfg(auto_reset: bool):
+  """Cartpole cfg with fixed-interval command and event timers.
+
+  Fixed ranges make timer values deterministic, so assertions are exact and
+  independent of RNG state and physics nondeterminism.
+  """
+  cfg = _make_cfg(auto_reset)
+  cfg.commands = {
+    "counter": CounterCommandCfg(resampling_time_range=(_COMMAND_T, _COMMAND_T))
+  }
+  cfg.events["probe"] = EventTermCfg(
+    func=_noop_event, mode="interval", interval_range_s=(_INTERVAL_T, _INTERVAL_T)
+  )
+  return cfg
+
+
+def _stagger_env0(env, steps_until_reset: int) -> torch.Tensor:
+  """Advance env 0's episode clock so it times out after the given steps."""
+  env.reset()
+  env.episode_length_buf[0] = env.max_episode_length - steps_until_reset
+  return torch.zeros((env.num_envs, 1), device=env.device)
+
+
+def test_auto_reset_preserves_fresh_command_timer(device):
+  """A command timer resampled by an auto-reset is not decremented that step."""
+  env = ManagerBasedRlEnv(cfg=_make_parity_cfg(auto_reset=True), device=device)
+  action = _stagger_env0(env, steps_until_reset=2)
+  env.step(action)
+  env.step(action)  # Env 0 times out and auto-resets here.
+  assert env.episode_length_buf[0].item() == 0
+
+  term = env.command_manager.get_term("counter")
+  assert isinstance(term, CounterCommand)
+  time_left = term.time_left
+  expected_running = _COMMAND_T - 2 * env.step_dt
+  assert torch.allclose(time_left[0], torch.tensor(_COMMAND_T, device=env.device))
+  assert torch.allclose(
+    time_left[1:], torch.tensor(expected_running, device=env.device)
+  )
+  env.close()
+
+
+def test_auto_reset_preserves_fresh_interval_event_timer(device):
+  """An interval event timer resampled by an auto-reset is not decremented."""
+  env = ManagerBasedRlEnv(cfg=_make_parity_cfg(auto_reset=True), device=device)
+  action = _stagger_env0(env, steps_until_reset=2)
+  env.step(action)
+  env.step(action)  # Env 0 times out and auto-resets here.
+  assert env.episode_length_buf[0].item() == 0
+
+  timer = env.event_manager._interval_term_time_left[0]
+  expected_running = _INTERVAL_T - 2 * env.step_dt
+  assert torch.allclose(timer[0], torch.tensor(_INTERVAL_T, device=env.device))
+  assert torch.allclose(timer[1:], torch.tensor(expected_running, device=env.device))
+  env.close()
+
+
+def test_interval_event_acts_on_pre_reset_state(device):
+  """An interval event firing on a reset step hits the terminal state, so the
+  freshly reset env comes out clean, as in the explicit reset flow."""
+  cfg = _make_cfg(auto_reset=True)
+  cfg.events["kick"] = EventTermCfg(
+    func=_write_marker_velocity, mode="interval", interval_range_s=(0.0, 0.0)
+  )
+  env = ManagerBasedRlEnv(cfg=cfg, device=device)
+  action = _stagger_env0(env, steps_until_reset=1)
+  env.step(action)  # Kick fires for all envs; env 0 then auto-resets.
+  assert env.episode_length_buf[0].item() == 0
+
+  joint_vel = env.scene["cartpole"].data.joint_vel
+  # Env 0 was reset after the kick: its velocity is the reset distribution's,
+  # not the marker. Env 1 was not reset and still carries the marker.
+  assert joint_vel[0].abs().max().item() < 1.0
+  assert torch.allclose(joint_vel[1], torch.full_like(joint_vel[1], _MARKER_VEL))
+  env.close()
+
+
+def test_auto_reset_matches_manual_reset_timers(device):
+  """After a reset, both flows leave identical command/event timer state."""
+  auto_env = ManagerBasedRlEnv(cfg=_make_parity_cfg(auto_reset=True), device=device)
+  manual_env = ManagerBasedRlEnv(cfg=_make_parity_cfg(auto_reset=False), device=device)
+  auto_env.reset(seed=0)
+  manual_env.reset(seed=0)
+
+  action = torch.zeros((auto_env.num_envs, 1), device=auto_env.device)
+  done = torch.zeros(auto_env.num_envs, dtype=torch.bool, device=auto_env.device)
+  for _ in range(auto_env.max_episode_length):
+    auto_env.step(action)
+    _, _, terminated, truncated, _ = manual_env.step(action)
+    done = terminated | truncated
+  done_ids = done.nonzero(as_tuple=False).squeeze(-1)
+  assert len(done_ids) == manual_env.num_envs  # Time-out is synchronized.
+  manual_env.reset(env_ids=done_ids)
+
+  for env in (auto_env, manual_env):
+    term = env.command_manager.get_term("counter")
+    assert isinstance(term, CounterCommand)
+    interval_timer = env.event_manager._interval_term_time_left[0]
+    assert torch.all(env.episode_length_buf == 0)
+    assert torch.allclose(term.time_left, torch.full_like(term.time_left, _COMMAND_T))
+    assert torch.allclose(interval_timer, torch.full_like(interval_timer, _INTERVAL_T))
+    # Stateful command advance: resample zeroed the counter, then exactly one
+    # post-reset update ran in both flows.
+    assert torch.all(term.ticks == 1)
+
+  auto_env.close()
+  manual_env.close()
diff --git a/tests/test_builtin_dcmotor_actuator.py b/tests/test_builtin_dcmotor_actuator.py
new file mode 100644
index 0000000..f5cff2a
--- /dev/null
+++ b/tests/test_builtin_dcmotor_actuator.py
@@ -0,0 +1,653 @@
+"""Tests for BuiltinDcMotorActuator.
+
+Covers wiring of MuJoCo's native ``<dcmotor>`` element through mjlab: the
+three input modes (voltage / position / velocity), torque saturation,
+config validation, and DR integration.
+"""
+
+import math
+from unittest.mock import Mock
+
+import mujoco
+import pytest
+import torch
+from conftest import (
+  create_entity_with_actuator,
+  get_test_device,
+  initialize_entity,
+  load_fixture_xml,
+)
+
+from mjlab.actuator import (
+  BuiltinDcMotorActuator,
+  BuiltinDcMotorActuatorCfg,
+  DcMotorDatasheetParams,
+  DcMotorInputMode,
+  DcMotorPhysicalParams,
+)
+from mjlab.actuator.actuator import TransmissionType
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.envs.mdp import dr
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.scene import Scene, SceneCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+ROBOT_XML = load_fixture_xml("floating_base_articulated")
+
+# Motor characterization used throughout (resolves to K=0.24, R=2.88).
+V_NOM, TAU_STALL, OMEGA_NL = 24.0, 2.0, 100.0
+K = V_NOM / OMEGA_NL
+R = K * V_NOM / TAU_STALL
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+DATASHEET = DcMotorDatasheetParams(
+  nominal_voltage=V_NOM, stall_torque=TAU_STALL, no_load_speed=OMEGA_NL
+)
+
+
+def _make_cfg(
+  *,
+  mode: DcMotorInputMode = DcMotorInputMode.POSITION,
+  stiffness=5.0,
+  damping=0.5,
+  voltage_limit=24.0,
+  **extra,
+) -> BuiltinDcMotorActuatorCfg:
+  """Build a cfg with sensible PID defaults. ``extra`` forwards any other
+  BuiltinDcMotorActuatorCfg kwarg (effort_limit, integral_gain, thermal,
+  delay_*, etc.)."""
+  return BuiltinDcMotorActuatorCfg(
+    target_names_expr=("joint.*",),
+    mode=mode,
+    motor_params=DATASHEET,
+    stiffness=stiffness,
+    damping=damping,
+    voltage_limit=voltage_limit,
+    **extra,
+  )
+
+
+def _make_entity(**kwargs) -> Entity:
+  return create_entity_with_actuator(ROBOT_XML, _make_cfg(**kwargs))
+
+
+def _make_initialized(device, **kwargs):
+  """Build entity from cfg kwargs and initialize it through the sim."""
+  return initialize_entity(_make_entity(**kwargs), device)
+
+
+def _drive(
+  entity: Entity,
+  sim,
+  device: str,
+  *,
+  pos_target=None,
+  vel_target=None,
+  effort_target=None,
+  q0=None,
+  qd0=None,
+) -> None:
+  zero = torch.zeros(1, 2, device=device)
+  entity.write_joint_state_to_sim(
+    position=q0 if q0 is not None else zero,
+    velocity=qd0 if qd0 is not None else zero,
+  )
+  entity.set_joint_position_target(pos_target if pos_target is not None else zero)
+  entity.set_joint_velocity_target(vel_target if vel_target is not None else zero)
+  entity.set_joint_effort_target(effort_target if effort_target is not None else zero)
+  entity.write_data_to_sim()
+  sim.forward()
+
+
+# Wiring sanity.
+
+
+def test_kr_packed_into_gainprm(device):
+  """The XML compiler derives K and R from the nominal triplet."""
+  _, sim = initialize_entity(_make_entity(effort_limit=1.5), device)
+  m = sim.mj_model
+  for i in range(2):
+    assert m.actuator_gainprm[i, 0] == pytest.approx(R, abs=1e-6)
+    assert m.actuator_gainprm[i, 1] == pytest.approx(K, abs=1e-6)
+    assert m.actuator_gainprm[i, 4] == pytest.approx(5.0)  # kp
+    assert m.actuator_gainprm[i, 6] == pytest.approx(0.5)  # kd
+    assert m.actuator_gainprm[i, 7] == pytest.approx(24.0)  # Vmax
+    assert m.actuator_gainprm[i, 8] == pytest.approx(1.0)  # input_mode=position
+    assert m.actuator_gaintype[i] == mujoco.mjtGain.mjGAIN_DCMOTOR
+    assert m.actuator_biastype[i] == mujoco.mjtBias.mjBIAS_DCMOTOR
+    # No activation state: ki=0, no inductance, no thermal/lugre/slew.
+    assert m.actuator_actnum[i] == 0
+
+
+def test_motor_const_path(device):
+  """Physical params pack K = sqrt(Kt*Ke) and R verbatim."""
+  cfg = BuiltinDcMotorActuatorCfg(
+    target_names_expr=("joint.*",),
+    mode=DcMotorInputMode.VOLTAGE,
+    motor_params=DcMotorPhysicalParams(kt=0.1, ke=0.05, resistance=2.0),
+  )
+  _, sim = initialize_entity(create_entity_with_actuator(ROBOT_XML, cfg), device)
+  m = sim.mj_model
+  for i in range(2):
+    assert m.actuator_gainprm[i, 0] == pytest.approx(2.0, abs=1e-6)
+    assert m.actuator_gainprm[i, 1] == pytest.approx((0.1 * 0.05) ** 0.5, abs=1e-6)
+
+
+# Stateless motor physics.
+
+
+def test_voltage_mode_steady_state(device):
+  """At rest, ctrl = V -> tau = K * V / R."""
+  cfg = BuiltinDcMotorActuatorCfg(
+    target_names_expr=("joint.*",),
+    mode=DcMotorInputMode.VOLTAGE,
+    motor_params=DATASHEET,
+  )
+  entity, sim = initialize_entity(create_entity_with_actuator(ROBOT_XML, cfg), device)
+  V = torch.tensor([[10.0, -5.0]], device=device)
+  _drive(entity, sim, device, effort_target=V)
+  v_adr = entity.indexing.joint_v_adr
+  expected = K * V[0] / R
+  assert torch.allclose(sim.data.qfrc_actuator[0, v_adr], expected, atol=1e-4)
+
+
+def test_voltage_mode_voltage_limit_zero_is_noop(device):
+  """Docstring promises ``voltage_limit=0`` disables clamping. Verify against
+  MuJoCo's ``dcmotor_voltage`` (which only clamps when ``Vmax > 0``)."""
+  cfg = BuiltinDcMotorActuatorCfg(
+    target_names_expr=("joint.*",),
+    mode=DcMotorInputMode.VOLTAGE,
+    motor_params=DATASHEET,
+    voltage_limit=0.0,
+  )
+  entity, sim = initialize_entity(create_entity_with_actuator(ROBOT_XML, cfg), device)
+  V = torch.tensor([[1000.0, 0.0]], device=device)  # absurdly high voltage.
+  _drive(entity, sim, device, effort_target=V)
+  v_adr = entity.indexing.joint_v_adr
+  expected = K * V[0] / R
+  assert torch.allclose(sim.data.qfrc_actuator[0, v_adr], expected, atol=1e-2)
+
+
+def test_back_emf_reduces_torque_at_velocity(device):
+  """Same V, joint moving at omega: tau = K * (V - K * omega) / R."""
+  cfg = BuiltinDcMotorActuatorCfg(
+    target_names_expr=("joint.*",),
+    mode=DcMotorInputMode.VOLTAGE,
+    motor_params=DATASHEET,
+  )
+  entity, sim = initialize_entity(create_entity_with_actuator(ROBOT_XML, cfg), device)
+  V = torch.tensor([[10.0, 0.0]], device=device)
+  omega0 = torch.tensor([[2.0, 0.0]], device=device)
+  _drive(entity, sim, device, effort_target=V, qd0=omega0)
+  v_adr = entity.indexing.joint_v_adr
+  expected = K * (V[0] - K * omega0[0]) / R
+  assert torch.allclose(sim.data.qfrc_actuator[0, v_adr], expected, atol=1e-4)
+
+
+def test_position_mode_pid_at_rest(device):
+  """kd=0, no Vmax clamp: tau = K * kp * (target - q) / R."""
+  # voltage_limit must be >0 (cfg invariant), pick it big enough not to clamp.
+  entity, sim = initialize_entity(
+    _make_entity(damping=0.0, voltage_limit=1000.0), device
+  )
+  pos = torch.tensor([[0.1, -0.05]], device=device)
+  _drive(entity, sim, device, pos_target=pos)
+  v_adr = entity.indexing.joint_v_adr
+  expected = K * 5.0 * pos[0] / R
+  assert torch.allclose(sim.data.qfrc_actuator[0, v_adr], expected, atol=1e-4)
+
+
+def test_position_mode_voltage_clamp(device):
+  """Huge position error -> PID voltage saturates at Vmax."""
+  entity, sim = initialize_entity(
+    _make_entity(stiffness=100.0, damping=0.0, voltage_limit=2.0),
+    device,
+  )
+  # kp * err = 100 * 0.5 = 50 V, well above Vmax=2.
+  pos = torch.tensor([[0.5, 0.0]], device=device)
+  _drive(entity, sim, device, pos_target=pos)
+  v_adr = entity.indexing.joint_v_adr
+  qfrc = sim.data.qfrc_actuator[0, v_adr]
+  expected_first = K * 2.0 / R  # tau at clamped V.
+  assert qfrc[0].item() == pytest.approx(expected_first, abs=1e-4)
+  assert qfrc[1].item() == pytest.approx(0.0, abs=1e-4)
+
+
+def test_velocity_mode_pid(device):
+  """P-only velocity tracking: tau = K * kp * (target - qdot) / R."""
+  entity, sim = initialize_entity(
+    _make_entity(mode=DcMotorInputMode.VELOCITY, damping=0.0, voltage_limit=1000.0),
+    device,
+  )
+  qd0 = torch.tensor([[1.0, 0.0]], device=device)
+  vel_target = torch.tensor([[3.0, 0.0]], device=device)
+  _drive(entity, sim, device, vel_target=vel_target, qd0=qd0)
+  v_adr = entity.indexing.joint_v_adr
+  # back-EMF subtracts K*omega; this is folded into the dcmotor bias.
+  # voltage = kp*(target - qdot); tau = K*(voltage - K*omega)/R.
+  voltage = 5.0 * (vel_target[0] - qd0[0])
+  expected = K * (voltage - K * qd0[0]) / R
+  assert torch.allclose(sim.data.qfrc_actuator[0, v_adr], expected, atol=1e-4)
+
+
+def test_effort_limit_clamps_torque(device):
+  """forcerange clamps the algebraic torque output."""
+  entity, sim = initialize_entity(
+    _make_entity(stiffness=100.0, damping=0.0, voltage_limit=1000.0, effort_limit=0.1),
+    device,
+  )
+  m = sim.mj_model
+  for i in range(2):
+    assert m.actuator_forcelimited[i] == 1
+    assert m.actuator_forcerange[i, 0] == pytest.approx(-0.1)
+    assert m.actuator_forcerange[i, 1] == pytest.approx(0.1)
+
+  # Unclamped tau would be K * 100 * 0.5 / R ~= K*50/R, well above 0.1.
+  pos = torch.tensor([[0.5, 0.0]], device=device)
+  _drive(entity, sim, device, pos_target=pos)
+  v_adr = entity.indexing.joint_v_adr
+  qfrc = sim.data.qfrc_actuator[0, v_adr]
+  assert qfrc[0].item() == pytest.approx(0.1, abs=1e-4)
+  assert qfrc[1].item() == pytest.approx(0.0, abs=1e-4)
+
+
+# Cogging.
+
+
+def test_cogging_packed_into_biasprm(device):
+  """``cogging=(A, Np, phi)`` packs into ``biasprm[0:3]``."""
+  cfg = BuiltinDcMotorActuatorCfg(
+    target_names_expr=("joint.*",),
+    mode=DcMotorInputMode.VOLTAGE,
+    motor_params=DATASHEET,
+    cogging=(0.5, 4.0, 0.1),
+  )
+  _, sim = initialize_entity(create_entity_with_actuator(ROBOT_XML, cfg), device)
+  m = sim.mj_model
+  for i in range(2):
+    assert m.actuator_biasprm[i, 0] == pytest.approx(0.5)
+    assert m.actuator_biasprm[i, 1] == pytest.approx(4.0)
+    assert m.actuator_biasprm[i, 2] == pytest.approx(0.1)
+
+
+def test_cogging_contributes_torque(device):
+  """At ctrl=0 (no electromagnetic torque), qfrc_actuator equals the cogging
+  term ``A * sin(Np * q + phi)`` evaluated at the joint angle."""
+  A, Np, phi = 0.5, 4.0, 0.1
+  cfg = BuiltinDcMotorActuatorCfg(
+    target_names_expr=("joint.*",),
+    mode=DcMotorInputMode.VOLTAGE,
+    motor_params=DATASHEET,
+    cogging=(A, Np, phi),
+  )
+  entity, sim = initialize_entity(create_entity_with_actuator(ROBOT_XML, cfg), device)
+  q0, q1 = 0.3, -0.2
+  _drive(
+    entity,
+    sim,
+    device,
+    q0=torch.tensor([[q0, q1]], device=device),
+    effort_target=torch.zeros(1, 2, device=device),
+  )
+  v_adr = entity.indexing.joint_v_adr
+  qfrc = sim.data.qfrc_actuator[0, v_adr]
+  assert qfrc[0].item() == pytest.approx(A * math.sin(Np * q0 + phi), abs=1e-5)
+  assert qfrc[1].item() == pytest.approx(A * math.sin(Np * q1 + phi), abs=1e-5)
+
+
+def test_cogging_bypasses_effort_limit(device):
+  """Cogging is added *after* the forcerange clamp (MuJoCo's intentional
+  model: ``effort_limit`` bounds electromagnetic torque, cogging is
+  mechanical). Total torque can exceed ``effort_limit`` by up to the
+  cogging amplitude."""
+  A, Np, phi = 0.5, 0.0, math.pi / 2  # sin(pi/2)=1, so cogging = A at any q.
+  cfg = BuiltinDcMotorActuatorCfg(
+    target_names_expr=("joint.*",),
+    mode=DcMotorInputMode.VOLTAGE,
+    motor_params=DATASHEET,
+    cogging=(A, Np, phi),
+    effort_limit=0.05,  # An order of magnitude below A.
+  )
+  entity, sim = initialize_entity(create_entity_with_actuator(ROBOT_XML, cfg), device)
+  # Pick a voltage large enough that the electromagnetic torque alone
+  # would saturate forcerange at +/- 0.05.
+  V = torch.tensor([[100.0, 0.0]], device=device)
+  _drive(entity, sim, device, effort_target=V)
+  v_adr = entity.indexing.joint_v_adr
+  qfrc = sim.data.qfrc_actuator[0, v_adr]
+  # joint1: electromagnetic clamped to +0.05, plus cogging A=0.5.
+  assert qfrc[0].item() == pytest.approx(0.05 + A, abs=1e-5)
+  # joint2: zero voltage, electromagnetic=0, only cogging.
+  assert qfrc[1].item() == pytest.approx(A, abs=1e-5)
+
+
+# Optional stateful extensions (integral, slew, inductance, thermal, LuGre).
+# Each behavior check compares against a baseline with the feature disabled
+# so that removing the wiring in edit_spec causes the comparison to fail.
+
+
+def _step_n(entity, sim, device, n: int, *, pos_target=None, eff_target=None):
+  zero = torch.zeros(1, 2, device=device)
+  entity.write_joint_state_to_sim(position=zero, velocity=zero)
+  for _ in range(n):
+    entity.set_joint_position_target(pos_target if pos_target is not None else zero)
+    entity.set_joint_velocity_target(zero)
+    entity.set_joint_effort_target(eff_target if eff_target is not None else zero)
+    entity.write_data_to_sim()
+    sim.step()
+
+
+def _qfrc(entity, sim) -> torch.Tensor:
+  return sim.data.qfrc_actuator[0, entity.indexing.joint_v_adr].clone()
+
+
+def test_integral_gain_ramps_torque(device):
+  """Integrator in position mode ramps torque over time even with ``kp``
+  and ``kd`` near zero."""
+  # stiffness must be > 0 (validation); choose tiny so ki dominates.
+  base = dict(
+    mode=DcMotorInputMode.POSITION, stiffness=1e-4, damping=0.0, voltage_limit=24.0
+  )
+  ent_off, sim_off = _make_initialized(device, **base, integral_gain=0.0)
+  ent_on, sim_on = _make_initialized(device, **base, integral_gain=10.0)
+
+  target = torch.tensor([[0.5, 0.0]], device=device)
+  for sim, ent in ((sim_off, ent_off), (sim_on, ent_on)):
+    _step_n(ent, sim, device, n=20, pos_target=target)
+  assert _qfrc(ent_on, sim_on)[0].abs() > 100.0 * _qfrc(ent_off, sim_off)[0].abs()
+
+
+def test_slew_rate_limits_voltage(device):
+  """``slew_rate`` rate-limits ``ctrl``: after one step, effective voltage
+  is far below the requested input."""
+  base = dict(
+    mode=DcMotorInputMode.VOLTAGE, stiffness=0.0, damping=0.0, voltage_limit=0.0
+  )
+  ent_off, sim_off = _make_initialized(device, **base, slew_rate=0.0)
+  ent_on, sim_on = _make_initialized(device, **base, slew_rate=10.0)
+
+  V = torch.tensor([[100.0, 0.0]], device=device)
+  for sim, ent in ((sim_off, ent_off), (sim_on, ent_on)):
+    _step_n(ent, sim, device, n=1, eff_target=V)
+  assert _qfrc(ent_off, sim_off)[0] > 100.0 * _qfrc(ent_on, sim_on)[0]
+
+
+def test_inductance_lags_current(device):
+  """Large ``inductance`` (te >> dt) suppresses early-step torque."""
+  base = dict(
+    mode=DcMotorInputMode.VOLTAGE, stiffness=0.0, damping=0.0, voltage_limit=0.0
+  )
+  ent_off, sim_off = _make_initialized(device, **base, inductance=0.0)
+  ent_on, sim_on = _make_initialized(device, **base, inductance=1.0)
+
+  V = torch.tensor([[10.0, 0.0]], device=device)
+  for sim, ent in ((sim_off, ent_off), (sim_on, ent_on)):
+    _step_n(ent, sim, device, n=2, eff_target=V)
+  assert _qfrc(ent_off, sim_off)[0].abs() > 10.0 * _qfrc(ent_on, sim_on)[0].abs()
+
+
+def test_thermal_decays_torque(device):
+  """I^2R heating raises T, which raises effective resistance and decays
+  torque over time."""
+  # Params chosen for visible effect in a handful of steps without going
+  # numerically unstable: small C (fast heating) and modest alpha.
+  base = dict(
+    mode=DcMotorInputMode.VOLTAGE, stiffness=0.0, damping=0.0, voltage_limit=0.0
+  )
+  ent_off, sim_off = _make_initialized(device, **base)
+  ent_on, sim_on = _make_initialized(
+    device, **base, thermal=(1.0, 0.1, 0.0, 0.01, 0.0, 0.0)
+  )
+
+  V = torch.tensor([[100.0, 0.0]], device=device)
+  for sim, ent in ((sim_off, ent_off), (sim_on, ent_on)):
+    _step_n(ent, sim, device, n=5, eff_target=V)
+  assert _qfrc(ent_on, sim_on)[0].abs() < 0.5 * _qfrc(ent_off, sim_off)[0].abs()
+
+
+def test_lugre_subtracts_friction(device):
+  """LuGre friction subtracts a velocity-dependent force after the
+  ``effort_limit`` clamp (mechanical, like cogging)."""
+  # Static comparison at v>0, ctrl=0; avoids feedback between LuGre slowing
+  # the joint and back-EMF easing off under sim.step().
+  #   no LuGre:  qfrc = -K^2 * v / R              (back-EMF only)
+  #   w/ LuGre:  qfrc = -K^2 * v / R - sigma1*v - ...
+  base = dict(
+    mode=DcMotorInputMode.VOLTAGE, stiffness=0.0, damping=0.0, voltage_limit=0.0
+  )
+  ent_off, sim_off = _make_initialized(device, **base)
+  ent_on, sim_on = _make_initialized(
+    device, **base, lugre=(1e4, 100.0, 0.1, 0.15, 0.01)
+  )
+
+  zero = torch.zeros(1, 2, device=device)
+  v0 = torch.tensor([[1.0, 0.0]], device=device)
+  for sim, ent in ((sim_off, ent_off), (sim_on, ent_on)):
+    ent.write_joint_state_to_sim(position=zero, velocity=v0)
+    ent.set_joint_position_target(zero)
+    ent.set_joint_velocity_target(zero)
+    ent.set_joint_effort_target(zero)
+    ent.write_data_to_sim()
+    sim.forward()
+  assert abs(_qfrc(ent_on, sim_on)[0]) > 100.0 * abs(_qfrc(ent_off, sim_off)[0])
+
+
+# Config validation.
+
+
+def test_pid_mode_requires_gains():
+  with pytest.raises(ValueError, match="stiffness"):
+    BuiltinDcMotorActuatorCfg(
+      target_names_expr=("j",),
+      mode=DcMotorInputMode.POSITION,
+      motor_params=DATASHEET,
+      voltage_limit=1.0,
+    )
+  with pytest.raises(ValueError, match="voltage_limit"):
+    BuiltinDcMotorActuatorCfg(
+      target_names_expr=("j",),
+      mode=DcMotorInputMode.POSITION,
+      motor_params=DATASHEET,
+      stiffness=1.0,
+    )
+
+
+def test_voltage_mode_rejects_pid_gains():
+  with pytest.raises(ValueError, match="VOLTAGE"):
+    BuiltinDcMotorActuatorCfg(
+      target_names_expr=("j",),
+      mode=DcMotorInputMode.VOLTAGE,
+      motor_params=DATASHEET,
+      stiffness=1.0,
+    )
+
+
+def test_site_rejected():
+  with pytest.raises(ValueError, match="SITE"):
+    BuiltinDcMotorActuatorCfg(
+      target_names_expr=("j",),
+      motor_params=DATASHEET,
+      stiffness=1.0,
+      voltage_limit=1.0,
+      transmission_type=TransmissionType.SITE,
+    )
+
+
+# Joint-level passthrough.
+
+
+def test_armature_applied(device):
+  _, sim = initialize_entity(_make_entity(armature=0.7), device)
+  m = sim.mj_model
+  for jname in ("joint1", "joint2"):
+    dof_id = m.jnt_dofadr[m.joint(jname).id]
+    assert m.dof_armature[dof_id] == pytest.approx(0.7)
+
+
+# Domain randomization.
+
+
+def _scene_env(
+  device,
+  num_envs=2,
+  mode: DcMotorInputMode = DcMotorInputMode.POSITION,
+):
+  def spec_fn():
+    spec = mujoco.MjSpec.from_string(ROBOT_XML)
+    for a in list(spec.actuators):
+      spec.delete(a)
+    return spec
+
+  entity_cfg = EntityCfg(
+    spec_fn=spec_fn,
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinDcMotorActuatorCfg(
+          target_names_expr=("joint.*",),
+          mode=mode,
+          motor_params=DATASHEET,
+          stiffness=5.0 if mode != DcMotorInputMode.VOLTAGE else 0.0,
+          damping=0.5 if mode != DcMotorInputMode.VOLTAGE else 0.0,
+          voltage_limit=24.0 if mode != DcMotorInputMode.VOLTAGE else 0.0,
+          effort_limit=50.0,
+        ),
+      )
+    ),
+  )
+  scene_cfg = SceneCfg(num_envs=num_envs, entities={"robot": entity_cfg})
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim = Simulation(num_envs=num_envs, cfg=SimulationCfg(), model=model, device=device)
+  scene.initialize(model, sim.model, sim.data)
+
+  env = Mock()
+  env.num_envs = num_envs
+  env.device = device
+  env.scene = {"robot": scene["robot"]}
+  env.sim = sim
+  return env
+
+
+@pytest.mark.parametrize(
+  "operation, kp_in, kd_in, kp_expected, kd_expected",
+  [
+    # scale: multiplies the configured defaults (kp=5.0, kd=0.5).
+    ("scale", 2.0, 3.0, 2.0 * 5.0, 3.0 * 0.5),
+    # abs: writes the value directly.
+    ("abs", 10.0, 2.0, 10.0, 2.0),
+  ],
+)
+def test_dr_pd_gains_position_mode(
+  device, operation, kp_in, kd_in, kp_expected, kd_expected
+):
+  env = _scene_env(device)
+  robot = env.scene["robot"]
+  act = robot.actuators[0]
+  assert isinstance(act, BuiltinDcMotorActuator)
+  ctrl_ids = act.global_ctrl_ids
+  env.sim.expand_model_fields(("actuator_gainprm", "actuator_biasprm"))
+
+  dr.pd_gains(
+    env,
+    env_ids=torch.tensor([0], device=device),
+    kp_range=(kp_in, kp_in),
+    kd_range=(kd_in, kd_in),
+    asset_cfg=SceneEntityCfg("robot"),
+    operation=operation,
+  )
+
+  m = env.sim.model
+  n = len(ctrl_ids)
+  assert torch.allclose(
+    m.actuator_gainprm[0, ctrl_ids, 4], torch.full((n,), kp_expected, device=device)
+  )
+  assert torch.allclose(
+    m.actuator_gainprm[0, ctrl_ids, 6], torch.full((n,), kd_expected, device=device)
+  )
+  # Other env untouched (cfg defaults).
+  assert torch.allclose(m.actuator_gainprm[1, ctrl_ids, 4], torch.tensor(5.0))
+  assert torch.allclose(m.actuator_gainprm[1, ctrl_ids, 6], torch.tensor(0.5))
+
+
+def test_dr_pd_gains_voltage_mode_rejected(device):
+  env = _scene_env(device, mode=DcMotorInputMode.VOLTAGE)
+  env.sim.expand_model_fields(("actuator_gainprm", "actuator_biasprm"))
+  with pytest.raises(ValueError, match="VOLTAGE"):
+    dr.pd_gains(
+      env,
+      env_ids=torch.tensor([0], device=device),
+      kp_range=(1.0, 1.0),
+      kd_range=(1.0, 1.0),
+      asset_cfg=SceneEntityCfg("robot"),
+    )
+
+
+def test_dr_effort_limits_writes_forcerange(device):
+  env = _scene_env(device)
+  robot = env.scene["robot"]
+  act = robot.actuators[0]
+  ctrl_ids = act.global_ctrl_ids
+  env.sim.expand_model_fields(
+    ("actuator_forcerange", "jnt_actfrcrange", "tendon_actfrcrange")
+  )
+
+  dr.effort_limits(
+    env,
+    env_ids=torch.tensor([0], device=device),
+    effort_limit_range=(123.0, 123.0),
+    asset_cfg=SceneEntityCfg("robot"),
+    operation="abs",
+  )
+
+  m = env.sim.model
+  n = len(ctrl_ids)
+  assert torch.allclose(
+    m.actuator_forcerange[0, ctrl_ids, 0],
+    torch.full((n,), -123.0, device=device),
+  )
+  assert torch.allclose(
+    m.actuator_forcerange[0, ctrl_ids, 1],
+    torch.full((n,), 123.0, device=device),
+  )
+  # Env 1 keeps the configured default of 50.
+  assert torch.allclose(m.actuator_forcerange[1, ctrl_ids, 1], torch.tensor(50.0))
+
+
+# Delay.
+
+
+def test_delay_position_mode(device):
+  """A 2-step lag should make position-mode torque reference step-0 target."""
+  entity, sim = initialize_entity(
+    _make_entity(
+      stiffness=10.0,
+      damping=0.0,
+      voltage_limit=1000.0,
+      delay_min_lag=2,
+      delay_max_lag=2,
+    ),
+    device,
+  )
+  zero = torch.zeros(1, 2, device=device)
+  entity.write_joint_state_to_sim(position=zero, velocity=zero)
+  targets = [
+    torch.tensor([[0.1, 0.0]], device=device),
+    torch.tensor([[0.3, 0.0]], device=device),
+    torch.tensor([[0.5, 0.0]], device=device),
+  ]
+  for p in targets:
+    entity.set_joint_position_target(p)
+    entity.set_joint_velocity_target(zero)
+    entity.set_joint_effort_target(zero)
+    entity.write_data_to_sim()
+    sim.forward()
+
+  v_adr = entity.indexing.joint_v_adr
+  # With lag=2 and three writes, the effective target is targets[0].
+  expected = K * 10.0 * targets[0][0] / R
+  assert torch.allclose(sim.data.qfrc_actuator[0, v_adr], expected, atol=1e-4)
diff --git a/tests/test_builtin_group.py b/tests/test_builtin_group.py
new file mode 100644
index 0000000..b8e6434
--- /dev/null
+++ b/tests/test_builtin_group.py
@@ -0,0 +1,182 @@
+"""Tests for BuiltinActuatorGroup (unified delayed + non-delayed)."""
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device, load_fixture_xml
+
+from mjlab.actuator import (
+  BuiltinPositionActuatorCfg,
+  IdealPdActuatorCfg,
+)
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+ROBOT_XML = load_fixture_xml("floating_base_articulated")
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+def make_entity(actuator_cfgs, num_envs, device):
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML),
+    articulation=EntityArticulationInfoCfg(actuators=actuator_cfgs),
+  )
+  entity = Entity(cfg)
+  model = entity.compile()
+  sim = Simulation(num_envs=num_envs, cfg=SimulationCfg(), model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+  return entity, sim
+
+
+def test_fused_group_created(device):
+  """Delayed builtins with same config are fused into one group."""
+  cfg1 = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint1",),
+    stiffness=50.0,
+    damping=5.0,
+    delay_min_lag=1,
+    delay_max_lag=3,
+  )
+  cfg2 = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint2",),
+    stiffness=50.0,
+    damping=5.0,
+    delay_min_lag=1,
+    delay_max_lag=3,
+  )
+  entity, _ = make_entity((cfg1, cfg2), num_envs=2, device=device)
+
+  assert len(entity._builtin_group._delayed_groups) == 1
+  assert len(entity._custom_actuators) == 0
+
+
+def test_different_delay_configs_separate_groups(device):
+  """Delayed builtins with different delay configs get separate groups."""
+  cfg1 = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint1",),
+    stiffness=50.0,
+    damping=5.0,
+    delay_min_lag=1,
+    delay_max_lag=3,
+  )
+  cfg2 = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint2",),
+    stiffness=50.0,
+    damping=5.0,
+    delay_min_lag=5,
+    delay_max_lag=10,
+  )
+  entity, _ = make_entity((cfg1, cfg2), num_envs=2, device=device)
+
+  assert len(entity._builtin_group._delayed_groups) == 2
+
+
+def test_non_builtin_delayed_not_fused(device):
+  """Builtin delay fusion does not absorb ideal PD actuators.
+
+  The ideal PD actuator is fused separately into the PD group, not into the
+  builtin group and not left on the per-actuator custom path.
+  """
+  delayed_builtin = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint1",),
+    stiffness=50.0,
+    damping=5.0,
+    delay_min_lag=1,
+    delay_max_lag=3,
+  )
+  custom = IdealPdActuatorCfg(
+    target_names_expr=("joint2",),
+    stiffness=50.0,
+    damping=5.0,
+    effort_limit=100.0,
+  )
+  entity, _ = make_entity((delayed_builtin, custom), num_envs=2, device=device)
+
+  assert len(entity._builtin_group._delayed_groups) == 1
+  assert len(entity._fused_actuator_group._groups) == 1
+  assert len(entity._custom_actuators) == 0
+
+
+def test_delayed_controls_written(device):
+  """Fused delayed builtins write controls to sim correctly."""
+  cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint.*",),
+    stiffness=50.0,
+    damping=5.0,
+    delay_min_lag=0,
+    delay_max_lag=0,
+  )
+  entity, sim = make_entity((cfg,), num_envs=1, device=device)
+
+  target = torch.tensor([[0.5, -0.3]], device=device)
+  entity.set_joint_position_target(target)
+  entity.write_data_to_sim()
+
+  # With lag=0, output equals input.
+  assert torch.allclose(sim.data.ctrl[0], target[0])
+
+
+def test_delay_actually_delays(device):
+  """With nonzero fixed lag, a new target takes lag steps to appear."""
+  cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint.*",),
+    stiffness=50.0,
+    damping=5.0,
+    delay_min_lag=2,
+    delay_max_lag=2,
+  )
+  entity, sim = make_entity((cfg,), num_envs=1, device=device)
+
+  target_a = torch.tensor([[1.0, 2.0]], device=device)
+  target_b = torch.tensor([[5.0, 6.0]], device=device)
+
+  # Fill the buffer with target_a so lag clamp doesn't mask the test.
+  for _ in range(3):
+    entity.set_joint_position_target(target_a)
+    entity.write_data_to_sim()
+  assert torch.allclose(sim.data.ctrl[0], target_a[0])
+
+  # Now send target_b. With lag=2, it takes 2 more steps to arrive.
+  entity.set_joint_position_target(target_b)
+  entity.write_data_to_sim()
+  assert torch.allclose(sim.data.ctrl[0], target_a[0])  # still old
+
+  entity.set_joint_position_target(target_b)
+  entity.write_data_to_sim()
+  assert torch.allclose(sim.data.ctrl[0], target_a[0])  # still old
+
+  entity.set_joint_position_target(target_b)
+  entity.write_data_to_sim()
+  assert torch.allclose(sim.data.ctrl[0], target_b[0])  # now arrives
+
+
+def test_reset_clears_buffer(device):
+  """Reset clears delay buffers so old values don't leak through."""
+  cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint.*",),
+    stiffness=50.0,
+    damping=5.0,
+    delay_min_lag=2,
+    delay_max_lag=2,
+  )
+  entity, sim = make_entity((cfg,), num_envs=1, device=device)
+
+  target_a = torch.tensor([[1.0, 2.0]], device=device)
+  target_b = torch.tensor([[5.0, 6.0]], device=device)
+
+  # Fill buffer with target_a.
+  for _ in range(3):
+    entity.set_joint_position_target(target_a)
+    entity.write_data_to_sim()
+  assert torch.allclose(sim.data.ctrl[0], target_a[0])
+
+  # Reset, then fill with target_b. Old target_a must not appear.
+  entity.reset(torch.tensor([0], device=device))
+  for _ in range(3):
+    entity.set_joint_position_target(target_b)
+    entity.write_data_to_sim()
+  assert torch.allclose(sim.data.ctrl[0], target_b[0])
diff --git a/tests/test_builtin_pd_actuator.py b/tests/test_builtin_pd_actuator.py
new file mode 100644
index 0000000..e474e7a
--- /dev/null
+++ b/tests/test_builtin_pd_actuator.py
@@ -0,0 +1,468 @@
+"""Tests for BuiltinPdActuator.
+
+Covers the unique surface of the actuator: paired <position>/<velocity>
+elements per target, joint/tendon-level actfrcrange sum-clamp, DR for both
+gains and effort limits, delay synchronization, and the ordering invariant
+that DR depends on.
+"""
+
+from unittest.mock import Mock
+
+import mujoco
+import pytest
+import torch
+from conftest import (
+  create_entity_with_actuator,
+  get_test_device,
+  initialize_entity,
+  load_fixture_xml,
+)
+
+from mjlab.actuator import BuiltinPdActuator, BuiltinPdActuatorCfg
+from mjlab.actuator.actuator import TransmissionType
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.envs.mdp import dr
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.scene import Scene, SceneCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+ROBOT_XML = load_fixture_xml("floating_base_articulated")
+KP = 100.0
+KD = 10.0
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+def _make_entity(
+  *,
+  effort_limit: float | None = 50.0,
+  armature: float | None = None,
+  delay_max_lag: int = 0,
+  delay_min_lag: int = 0,
+  delay_hold_prob: float = 0.0,
+) -> Entity:
+  cfg = BuiltinPdActuatorCfg(
+    target_names_expr=("joint.*",),
+    stiffness=KP,
+    damping=KD,
+    effort_limit=effort_limit,
+    armature=armature,
+    delay_min_lag=delay_min_lag,
+    delay_max_lag=delay_max_lag,
+    delay_hold_prob=delay_hold_prob,
+  )
+  return create_entity_with_actuator(ROBOT_XML, cfg)
+
+
+def _at_rest_with_targets(
+  entity: Entity,
+  sim,
+  device: str,
+  pos_target: torch.Tensor,
+  vel_target: torch.Tensor,
+) -> None:
+  entity.write_joint_state_to_sim(
+    position=torch.zeros(1, 2, device=device),
+    velocity=torch.zeros(1, 2, device=device),
+  )
+  entity.set_joint_position_target(pos_target)
+  entity.set_joint_velocity_target(vel_target)
+  entity.set_joint_effort_target(torch.zeros(1, 2, device=device))
+  entity.write_data_to_sim()
+  sim.forward()
+
+
+# ---------------------------------------------------------------------------
+# Structural invariants
+# ---------------------------------------------------------------------------
+
+
+def test_two_ctrls_per_target_with_pos_then_vel_layout(device):
+  """Each target gets one <position> + one <velocity>, in halves."""
+  entity, sim = initialize_entity(_make_entity(), device)
+  act = entity.actuators[0]
+  assert isinstance(act, BuiltinPdActuator)
+
+  n = act.num_targets
+  assert n == len(act.target_names) == 2
+  assert len(act.ctrl_ids) == 2 * n
+  assert len(act.global_ctrl_ids) == 2 * n
+
+  names = [sim.mj_model.actuator(i).name for i in act.global_ctrl_ids.tolist()]
+  assert names[:n] == [f"{name}_pd_pos" for name in act.target_names]
+  assert names[n:] == [f"{name}_pd_vel" for name in act.target_names]
+
+
+def test_site_transmission_rejected():
+  with pytest.raises(ValueError, match="SITE"):
+    BuiltinPdActuatorCfg(
+      target_names_expr=("x",),
+      stiffness=1.0,
+      damping=1.0,
+      transmission_type=TransmissionType.SITE,
+    )
+
+
+def test_armature_applied_once(device):
+  """Joint armature must come from the position element only; double-applying
+  would silently double dof_armature."""
+  _, sim = initialize_entity(_make_entity(armature=0.7), device)
+  m = sim.mj_model
+  for jname in ("joint1", "joint2"):
+    dof_id = m.jnt_dofadr[m.joint(jname).id]
+    assert m.dof_armature[dof_id] == pytest.approx(0.7)
+
+
+# ---------------------------------------------------------------------------
+# Force computation
+# ---------------------------------------------------------------------------
+
+
+def test_position_only(device):
+  """Zero vel target: qfrc = kp * pos_target."""
+  entity, sim = initialize_entity(_make_entity(effort_limit=None), device)
+  pos = torch.tensor([[0.1, -0.05]], device=device)
+  _at_rest_with_targets(entity, sim, device, pos, torch.zeros(1, 2, device=device))
+  v_adr = entity.indexing.joint_v_adr
+  assert torch.allclose(sim.data.qfrc_actuator[0, v_adr], KP * pos[0], atol=1e-4)
+
+
+def test_velocity_only(device):
+  """Zero pos target, joint at rest: qfrc = kd * vel_target."""
+  entity, sim = initialize_entity(_make_entity(effort_limit=None), device)
+  vel = torch.tensor([[0.3, -0.2]], device=device)
+  _at_rest_with_targets(entity, sim, device, torch.zeros(1, 2, device=device), vel)
+  v_adr = entity.indexing.joint_v_adr
+  assert torch.allclose(sim.data.qfrc_actuator[0, v_adr], KD * vel[0], atol=1e-4)
+
+
+def test_pd_superposition(device):
+  """Both targets nonzero: qfrc = kp * pos_target + kd * vel_target."""
+  entity, sim = initialize_entity(_make_entity(effort_limit=None), device)
+  pos = torch.tensor([[0.1, -0.05]], device=device)
+  vel = torch.tensor([[0.2, -0.1]], device=device)
+  _at_rest_with_targets(entity, sim, device, pos, vel)
+  v_adr = entity.indexing.joint_v_adr
+  expected = KP * pos[0] + KD * vel[0]
+  assert torch.allclose(sim.data.qfrc_actuator[0, v_adr], expected, atol=1e-4)
+
+
+def test_actfrcrange_sum_clamp(device):
+  """A pos error big enough to make kp*err exceed effort_limit must be
+  clamped at the joint, not allowed to ride through the unbounded element."""
+  entity, sim = initialize_entity(_make_entity(effort_limit=5.0), device)
+  # kp * 10.0 = 1000, well over the 5.0 clamp.
+  pos = torch.tensor([[10.0, 0.0]], device=device)
+  _at_rest_with_targets(entity, sim, device, pos, torch.zeros(1, 2, device=device))
+  v_adr = entity.indexing.joint_v_adr
+  qfrc = sim.data.qfrc_actuator[0, v_adr]
+  assert qfrc[0].item() == pytest.approx(5.0, abs=1e-4)
+  assert qfrc[1].item() == pytest.approx(0.0, abs=1e-4)
+
+
+def test_effort_limit_none_leaves_joint_unlimited(device):
+  """effort_limit=None: jnt_actfrclimited stays 0 on the targeted joints."""
+  _, sim = initialize_entity(_make_entity(effort_limit=None), device)
+  m = sim.mj_model
+  for jname in ("joint1", "joint2"):
+    jid = m.joint(jname).id
+    assert m.jnt_actfrclimited[jid] == 0
+
+
+def test_actuator_forcerange_not_set(device):
+  """We deliberately leave per-element forcerange unset; the limit lives on
+  the joint. Inspection of actuator_force[i] thus shows the unclamped value."""
+  entity, sim = initialize_entity(_make_entity(effort_limit=5.0), device)
+  m = sim.mj_model
+  for ctrl_id in entity.actuators[0].global_ctrl_ids.tolist():
+    assert m.actuator_forcelimited[ctrl_id] == 0
+
+
+# ---------------------------------------------------------------------------
+# Delay synchronization
+# ---------------------------------------------------------------------------
+
+
+def test_delay_syncs_pos_and_vel(device):
+  """The shared delay buffer must lag pos and vel together."""
+  entity, sim = initialize_entity(
+    _make_entity(effort_limit=None, delay_min_lag=2, delay_max_lag=2),
+    device,
+  )
+  pos_targets = [
+    torch.tensor([[0.1, 0.0]], device=device),
+    torch.tensor([[0.3, 0.0]], device=device),
+    torch.tensor([[0.5, 0.0]], device=device),
+  ]
+  vel_targets = [
+    torch.tensor([[1.0, 0.0]], device=device),
+    torch.tensor([[2.0, 0.0]], device=device),
+    torch.tensor([[3.0, 0.0]], device=device),
+  ]
+  entity.write_joint_state_to_sim(
+    position=torch.zeros(1, 2, device=device),
+    velocity=torch.zeros(1, 2, device=device),
+  )
+  for p, v in zip(pos_targets, vel_targets, strict=True):
+    entity.set_joint_position_target(p)
+    entity.set_joint_velocity_target(v)
+    entity.set_joint_effort_target(torch.zeros(1, 2, device=device))
+    entity.write_data_to_sim()
+    sim.forward()
+
+  v_adr = entity.indexing.joint_v_adr
+  # With lag=2, both halves should reference step-0 values.
+  expected = KP * pos_targets[0][0] + KD * vel_targets[0][0]
+  assert torch.allclose(sim.data.qfrc_actuator[0, v_adr], expected, atol=1e-4)
+
+
+def test_reset_clears_delay_buffer(device):
+  entity, _ = initialize_entity(_make_entity(delay_min_lag=1, delay_max_lag=3), device)
+  act = entity.actuators[0]
+  assert act._delay_buffer is not None
+  entity.set_joint_position_target(torch.full((1, 2), 0.5, device=device))
+  entity.set_joint_velocity_target(torch.zeros(1, 2, device=device))
+  entity.write_data_to_sim()
+
+  entity.reset(torch.tensor([0], device=device))
+  assert act._delay_buffer.current_lags[0] == 0
+
+
+# ---------------------------------------------------------------------------
+# Domain randomization
+# ---------------------------------------------------------------------------
+
+
+def _scene_env(device, transmission=TransmissionType.JOINT, num_envs=2):
+  """Build a real scene/sim with one BuiltinPd-driven entity for DR tests."""
+  if transmission == TransmissionType.JOINT:
+    xml = ROBOT_XML
+    targets = ("joint.*",)
+  else:
+    xml = load_fixture_xml("tendon_finger")
+    # tendon_finger ships with motor/position/velocity actuators; we need a
+    # bare spec so BuiltinPd can attach to the tendon without name clashes.
+    targets = ("finger_tendon",)
+
+  def spec_fn():
+    spec = mujoco.MjSpec.from_string(xml)
+    # Strip any pre-existing actuators so BuiltinPd's added elements own ctrl.
+    for a in list(spec.actuators):
+      spec.delete(a)
+    return spec
+
+  entity_cfg = EntityCfg(
+    spec_fn=spec_fn,
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinPdActuatorCfg(
+          target_names_expr=targets,
+          stiffness=KP,
+          damping=KD,
+          effort_limit=50.0,
+          transmission_type=transmission,
+        ),
+      )
+    ),
+  )
+  scene_cfg = SceneCfg(num_envs=num_envs, entities={"robot": entity_cfg})
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim = Simulation(num_envs=num_envs, cfg=SimulationCfg(), model=model, device=device)
+  scene.initialize(model, sim.model, sim.data)
+
+  env = Mock()
+  env.num_envs = num_envs
+  env.device = device
+  env.scene = {"robot": scene["robot"]}
+  env.sim = sim
+  return env
+
+
+def test_dr_pd_gains_scales_halves_independently(device):
+  env = _scene_env(device)
+  robot = env.scene["robot"]
+  act = robot.actuators[0]
+  assert isinstance(act, BuiltinPdActuator)
+  n = act.num_targets
+  pos_ids = act.global_ctrl_ids[:n]
+  vel_ids = act.global_ctrl_ids[n:]
+
+  # Expand fields so DR can write per-env.
+  env.sim.expand_model_fields(("actuator_gainprm", "actuator_biasprm"))
+
+  dr.pd_gains(
+    env,
+    env_ids=torch.tensor([0], device=device),
+    kp_range=(2.0, 2.0),
+    kd_range=(3.0, 3.0),
+    asset_cfg=SceneEntityCfg("robot"),
+    operation="scale",
+  )
+
+  m = env.sim.model
+  # Position half: gainprm[0] and biasprm[1] both scaled by kp=2, biasprm[2]
+  # must stay zero (no kd injection).
+  assert torch.allclose(
+    m.actuator_gainprm[0, pos_ids, 0],
+    torch.full((n,), 2.0 * KP, device=device),
+  )
+  assert torch.allclose(
+    m.actuator_biasprm[0, pos_ids, 1],
+    torch.full((n,), -2.0 * KP, device=device),
+  )
+  assert torch.allclose(
+    m.actuator_biasprm[0, pos_ids, 2], torch.zeros(n, device=device)
+  )
+  # Velocity half: gainprm[0] and biasprm[2] both scaled by kd=3, biasprm[1]
+  # stays zero (no kp injection).
+  assert torch.allclose(
+    m.actuator_gainprm[0, vel_ids, 0],
+    torch.full((n,), 3.0 * KD, device=device),
+  )
+  assert torch.allclose(
+    m.actuator_biasprm[0, vel_ids, 2],
+    torch.full((n,), -3.0 * KD, device=device),
+  )
+  assert torch.allclose(
+    m.actuator_biasprm[0, vel_ids, 1], torch.zeros(n, device=device)
+  )
+  # The other env must be untouched.
+  assert torch.allclose(m.actuator_gainprm[1, pos_ids, 0], torch.tensor(KP))
+  assert torch.allclose(m.actuator_gainprm[1, vel_ids, 0], torch.tensor(KD))
+
+
+def test_dr_pd_gains_abs_writes_correct_columns(device):
+  env = _scene_env(device)
+  robot = env.scene["robot"]
+  act = robot.actuators[0]
+  assert isinstance(act, BuiltinPdActuator)
+  n = act.num_targets
+  pos_ids = act.global_ctrl_ids[:n]
+  vel_ids = act.global_ctrl_ids[n:]
+  env.sim.expand_model_fields(("actuator_gainprm", "actuator_biasprm"))
+
+  dr.pd_gains(
+    env,
+    env_ids=torch.tensor([0, 1], device=device),
+    kp_range=(200.0, 200.0),
+    kd_range=(25.0, 25.0),
+    asset_cfg=SceneEntityCfg("robot"),
+    operation="abs",
+  )
+
+  m = env.sim.model
+  assert torch.allclose(
+    m.actuator_gainprm[:, pos_ids, 0],
+    torch.full((env.num_envs, n), 200.0, device=device),
+  )
+  assert torch.allclose(
+    m.actuator_biasprm[:, pos_ids, 1],
+    torch.full((env.num_envs, n), -200.0, device=device),
+  )
+  assert torch.allclose(
+    m.actuator_biasprm[:, pos_ids, 2],
+    torch.zeros(env.num_envs, n, device=device),
+  )
+  assert torch.allclose(
+    m.actuator_gainprm[:, vel_ids, 0],
+    torch.full((env.num_envs, n), 25.0, device=device),
+  )
+  assert torch.allclose(
+    m.actuator_biasprm[:, vel_ids, 2],
+    torch.full((env.num_envs, n), -25.0, device=device),
+  )
+
+
+def test_dr_effort_limits_writes_jnt_actfrcrange(device):
+  env = _scene_env(device, transmission=TransmissionType.JOINT)
+  robot = env.scene["robot"]
+  act = robot.actuators[0]
+  assert isinstance(act, BuiltinPdActuator)
+  env.sim.expand_model_fields(
+    ("actuator_forcerange", "jnt_actfrcrange", "tendon_actfrcrange")
+  )
+
+  joint_ids = robot.indexing.joint_ids[act.target_ids]
+  pre_forcerange = env.sim.model.actuator_forcerange.clone()
+
+  dr.effort_limits(
+    env,
+    env_ids=torch.tensor([0], device=device),
+    effort_limit_range=(123.0, 123.0),
+    asset_cfg=SceneEntityCfg("robot"),
+    operation="abs",
+  )
+
+  m = env.sim.model
+  # The joint sum-clamp was rewritten on env 0 only.
+  assert torch.allclose(
+    m.jnt_actfrcrange[0, joint_ids],
+    torch.tensor([[-123.0, 123.0]] * len(joint_ids), device=device),
+  )
+  assert torch.allclose(
+    m.jnt_actfrcrange[1, joint_ids],
+    torch.tensor([[-50.0, 50.0]] * len(joint_ids), device=device),
+  )
+  # Per-element actuator_forcerange must be untouched for BuiltinPd: that
+  # field belongs to the existing single-element actuator semantic.
+  assert torch.allclose(m.actuator_forcerange, pre_forcerange)
+
+
+def test_dr_effort_limits_scale_multiplies_default(device):
+  """``scale`` multiplies the configured ``effort_limit`` (50.0) by the sample."""
+  env = _scene_env(device, transmission=TransmissionType.JOINT)
+  robot = env.scene["robot"]
+  act = robot.actuators[0]
+  assert isinstance(act, BuiltinPdActuator)
+  env.sim.expand_model_fields(
+    ("actuator_forcerange", "jnt_actfrcrange", "tendon_actfrcrange")
+  )
+  joint_ids = robot.indexing.joint_ids[act.target_ids]
+
+  dr.effort_limits(
+    env,
+    env_ids=torch.tensor([0], device=device),
+    effort_limit_range=(2.0, 2.0),
+    asset_cfg=SceneEntityCfg("robot"),
+    operation="scale",
+  )
+
+  m = env.sim.model
+  # Default is [-50, 50], scaled by 2 -> [-100, 100].
+  assert torch.allclose(
+    m.jnt_actfrcrange[0, joint_ids],
+    torch.tensor([[-100.0, 100.0]] * len(joint_ids), device=device),
+  )
+
+
+def test_dr_effort_limits_writes_tendon_actfrcrange(device):
+  env = _scene_env(device, transmission=TransmissionType.TENDON)
+  robot = env.scene["robot"]
+  act = robot.actuators[0]
+  assert isinstance(act, BuiltinPdActuator)
+  env.sim.expand_model_fields(
+    ("actuator_forcerange", "jnt_actfrcrange", "tendon_actfrcrange")
+  )
+  tendon_ids = robot.indexing.tendon_ids[act.target_ids]
+
+  dr.effort_limits(
+    env,
+    env_ids=torch.tensor([0], device=device),
+    effort_limit_range=(77.0, 77.0),
+    asset_cfg=SceneEntityCfg("robot"),
+    operation="abs",
+  )
+
+  m = env.sim.model
+  assert torch.allclose(
+    m.tendon_actfrcrange[0, tendon_ids],
+    torch.tensor([[-77.0, 77.0]] * len(tendon_ids), device=device),
+  )
+  assert torch.allclose(
+    m.tendon_actfrcrange[1, tendon_ids],
+    torch.tensor([[-50.0, 50.0]] * len(tendon_ids), device=device),
+  )
diff --git a/tests/test_builtin_sensor.py b/tests/test_builtin_sensor.py
new file mode 100644
index 0000000..f245c63
--- /dev/null
+++ b/tests/test_builtin_sensor.py
@@ -0,0 +1,378 @@
+"""Tests for builtin_sensor.py."""
+
+from __future__ import annotations
+
+import copy
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.entity import EntityCfg
+from mjlab.scene import Scene, SceneCfg
+from mjlab.sensor.builtin_sensor import BuiltinSensorCfg, ObjRef
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+
+@pytest.fixture(scope="module")
+def device():
+  """Test device fixture."""
+  return get_test_device()
+
+
+@pytest.fixture(scope="module")
+def articulated_robot_xml():
+  """XML for a simple articulated robot with joints."""
+  return """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="5 5 0.1" pos="0 0 0"/>
+        <body name="base" pos="0 0 1">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="5.0"/>
+          <site name="base_site" pos="0 0 0"/>
+          <body name="link1" pos="0.3 0 0">
+            <joint name="joint1" type="hinge" axis="0 0 1" range="-1.57 1.57"/>
+            <geom name="link1_geom" type="box" size="0.1 0.1 0.1" mass="1.0"/>
+            <site name="link1_site" pos="0 0 0"/>
+          </body>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+
+@pytest.fixture(scope="module")
+def robot_with_xml_sensors():
+  """XML for robot with sensors already defined in the XML."""
+  return """
+    <mujoco>
+      <worldbody>
+        <body name="base" pos="0 0 1">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="5.0"/>
+          <site name="base_site" pos="0 0 0"/>
+          <body name="link1" pos="0.3 0 0">
+            <joint name="joint1" type="hinge" axis="0 0 1" range="-1.57 1.57"/>
+            <geom name="link1_geom" type="box" size="0.1 0.1 0.1" mass="1.0"/>
+            <site name="link1_site" pos="0 0 0"/>
+          </body>
+        </body>
+      </worldbody>
+      <sensor>
+        <jointpos name="xml_joint_sensor" joint="joint1"/>
+        <accelerometer name="xml_accel_sensor" site="base_site"/>
+        <gyro name="xml_gyro_sensor" site="link1_site"/>
+      </sensor>
+    </mujoco>
+  """
+
+
+def test_jointpos_sensor(articulated_robot_xml, device):
+  """Verify joint pos sensor returns correctly shaped tensor for scalar joint values."""
+  entity_cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(articulated_robot_xml)
+  )
+
+  jointpos_sensor_cfg = BuiltinSensorCfg(
+    name="joint1_pos",
+    sensor_type="jointpos",
+    obj=ObjRef(type="joint", name="joint1", entity="robot"),
+  )
+
+  scene_cfg = SceneCfg(
+    num_envs=2,
+    env_spacing=3.0,
+    entities={"robot": entity_cfg},
+    sensors=(jointpos_sensor_cfg,),
+  )
+
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim_cfg = SimulationCfg(njmax=20)
+  sim = Simulation(num_envs=2, cfg=sim_cfg, model=model, device=device)
+  scene.initialize(sim.mj_model, sim.model, sim.data)
+
+  sensor = scene["robot/joint1_pos"]
+  sim.step()
+  data = sensor.data
+
+  assert isinstance(data, torch.Tensor)
+  assert data.shape == (2, 1)
+
+
+def test_accelerometer_sensor(articulated_robot_xml, device):
+  """Verify accelerometer reads non-zero acceleration when robot is on floor."""
+  entity_cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(articulated_robot_xml)
+  )
+
+  accel_sensor_cfg = BuiltinSensorCfg(
+    name="base_accel",
+    sensor_type="accelerometer",
+    obj=ObjRef(type="site", name="base_site", entity="robot"),
+  )
+
+  scene_cfg = SceneCfg(
+    num_envs=2,
+    env_spacing=3.0,
+    entities={"robot": entity_cfg},
+    sensors=(accel_sensor_cfg,),
+  )
+
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  # The robot falls and rests on the floor here, generating contact
+  # constraints; njmax must accommodate the resting nefc (~32), unlike the
+  # other tests which only step once before the robot lands.
+  sim_cfg = SimulationCfg(njmax=40)
+  sim = Simulation(num_envs=2, cfg=sim_cfg, model=model, device=device)
+  scene.initialize(sim.mj_model, sim.model, sim.data)
+
+  sensor = scene["robot/base_accel"]
+
+  # Step until the robot falls (from z=1) and rests on the floor. During free
+  # fall the accelerometer correctly reads ~0 (zero proper acceleration); it
+  # only registers the ~g ground reaction once the robot has landed (~280
+  # steps), so step well past that.
+  for _ in range(400):
+    sim.step()
+
+  data = sensor.data
+
+  assert isinstance(data, torch.Tensor)
+  assert data.shape == (2, 3)
+  assert torch.any(torch.abs(data) > 0)
+
+
+def test_multiple_sensors(articulated_robot_xml, device):
+  """Verify multiple sensors can be registered and return correctly shaped data."""
+  entity_cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(articulated_robot_xml)
+  )
+
+  jointpos_cfg = BuiltinSensorCfg(
+    name="joint1_pos",
+    sensor_type="jointpos",
+    obj=ObjRef(type="joint", name="joint1", entity="robot"),
+  )
+  jointvel_cfg = BuiltinSensorCfg(
+    name="joint1_vel",
+    sensor_type="jointvel",
+    obj=ObjRef(type="joint", name="joint1", entity="robot"),
+  )
+  gyro_cfg = BuiltinSensorCfg(
+    name="base_gyro",
+    sensor_type="gyro",
+    obj=ObjRef(type="site", name="base_site", entity="robot"),
+  )
+
+  scene_cfg = SceneCfg(
+    num_envs=1,
+    env_spacing=3.0,
+    entities={"robot": entity_cfg},
+    sensors=(jointpos_cfg, jointvel_cfg, gyro_cfg),
+  )
+
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim_cfg = SimulationCfg(njmax=20)
+  sim = Simulation(num_envs=1, cfg=sim_cfg, model=model, device=device)
+  scene.initialize(sim.mj_model, sim.model, sim.data)
+
+  jointpos_sensor = scene["robot/joint1_pos"]
+  jointvel_sensor = scene["robot/joint1_vel"]
+  gyro_sensor = scene["robot/base_gyro"]
+
+  sim.step()
+
+  pos_data = jointpos_sensor.data
+  vel_data = jointvel_sensor.data
+  gyro_data = gyro_sensor.data
+
+  assert pos_data.shape == (1, 1)
+  assert vel_data.shape == (1, 1)
+  assert gyro_data.shape == (1, 3)
+
+
+def test_error_on_invalid_ref():
+  """Verify ValueError is raised when ref provided for unsupported sensor type."""
+  with pytest.raises(ValueError, match="does not support ref specification"):
+    BuiltinSensorCfg(
+      name="invalid_sensor",
+      sensor_type="jointpos",
+      obj=ObjRef(type="joint", name="joint1", entity="robot"),
+      ref=ObjRef(type="body", name="base"),
+    )
+
+
+def test_error_on_missing_obj():
+  """Verify ValueError is raised when obj is not provided for required sensor type."""
+  with pytest.raises(ValueError, match="requires obj with type='joint'"):
+    BuiltinSensorCfg(
+      name="invalid_sensor",
+      sensor_type="jointpos",
+    )
+
+
+def test_error_on_wrong_obj_type_for_site_sensor():
+  """Verify ValueError is raised when wrong obj type is used for site sensor."""
+  with pytest.raises(ValueError, match="requires obj.type='site'"):
+    BuiltinSensorCfg(
+      name="invalid_sensor",
+      sensor_type="accelerometer",
+      obj=ObjRef(type="body", name="base"),
+    )
+
+
+def test_error_on_wrong_obj_type_for_body_sensor():
+  """Verify ValueError is raised when wrong obj type is used for body sensor."""
+  with pytest.raises(ValueError, match="requires obj.type='body'"):
+    BuiltinSensorCfg(
+      name="invalid_sensor",
+      sensor_type="subtreecom",
+      obj=ObjRef(type="site", name="base"),
+    )
+
+
+def test_error_on_wrong_obj_type_for_joint_sensor():
+  """Verify ValueError is raised when wrong obj type is used for joint sensor."""
+  with pytest.raises(ValueError, match="requires obj.type='joint'"):
+    BuiltinSensorCfg(
+      name="invalid_sensor",
+      sensor_type="jointvel",
+      obj=ObjRef(type="body", name="base"),
+    )
+
+
+def test_spatial_frame_sensor_accepts_multiple_types():
+  """Verify spatial frame sensors accept body, xbody, geom, site, camera."""
+  BuiltinSensorCfg(
+    name="frame_sensor_body",
+    sensor_type="framepos",
+    obj=ObjRef(type="body", name="test"),
+  )
+  BuiltinSensorCfg(
+    name="frame_sensor_xbody",
+    sensor_type="framepos",
+    obj=ObjRef(type="xbody", name="test"),
+  )
+  BuiltinSensorCfg(
+    name="frame_sensor_geom",
+    sensor_type="framepos",
+    obj=ObjRef(type="geom", name="test"),
+  )
+  BuiltinSensorCfg(
+    name="frame_sensor_site",
+    sensor_type="framepos",
+    obj=ObjRef(type="site", name="test"),
+  )
+  BuiltinSensorCfg(
+    name="frame_sensor_camera",
+    sensor_type="framepos",
+    obj=ObjRef(type="camera", name="test"),
+  )
+
+
+def test_xml_sensors_auto_discovered(robot_with_xml_sensors, device):
+  """Verify sensors defined in entity XML are automatically discovered and exposed."""
+  entity_cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(robot_with_xml_sensors)
+  )
+
+  scene_cfg = SceneCfg(
+    num_envs=2,
+    env_spacing=3.0,
+    entities={"robot": entity_cfg},
+    sensors=(),
+  )
+
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim_cfg = SimulationCfg(njmax=20)
+  sim = Simulation(num_envs=2, cfg=sim_cfg, model=model, device=device)
+  scene.initialize(sim.mj_model, sim.model, sim.data)
+
+  joint_sensor = scene["robot/xml_joint_sensor"]
+  accel_sensor = scene["robot/xml_accel_sensor"]
+  gyro_sensor = scene["robot/xml_gyro_sensor"]
+
+  sim.step()
+
+  joint_data = joint_sensor.data
+  accel_data = accel_sensor.data
+  gyro_data = gyro_sensor.data
+
+  assert isinstance(joint_data, torch.Tensor)
+  assert joint_data.shape == (2, 1)
+  assert isinstance(accel_data, torch.Tensor)
+  assert accel_data.shape == (2, 3)
+  assert isinstance(gyro_data, torch.Tensor)
+  assert gyro_data.shape == (2, 3)
+
+
+def test_builtin_sensor_errors_on_duplicate_name(robot_with_xml_sensors, device):
+  """Verify BuiltinSensorCfg throws error when name conflicts with XML sensor."""
+  entity_cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(robot_with_xml_sensors)
+  )
+
+  duplicate_sensor_cfg = BuiltinSensorCfg(
+    name="xml_joint_sensor",
+    sensor_type="jointpos",
+    obj=ObjRef(type="joint", name="joint1", entity="robot"),
+  )
+
+  scene_cfg = SceneCfg(
+    num_envs=2,
+    env_spacing=3.0,
+    entities={"robot": entity_cfg},
+    sensors=(duplicate_sensor_cfg,),
+  )
+
+  with pytest.raises(ValueError, match="defined in both entity XML and scene config"):
+    Scene(scene_cfg, device)
+
+
+def test_cutoff_parameter(articulated_robot_xml, device):
+  """Verify cutoff parameter propagates to MuJoCo model."""
+  entity_cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(articulated_robot_xml)
+  )
+
+  sensor_cfg = BuiltinSensorCfg(
+    name="joint1_pos",
+    sensor_type="jointpos",
+    obj=ObjRef(type="joint", name="joint1", entity="robot"),
+    cutoff=0.01,
+  )
+
+  scene_cfg = SceneCfg(
+    num_envs=1,
+    env_spacing=3.0,
+    entities={"robot": entity_cfg},
+    sensors=(sensor_cfg,),
+  )
+
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim_cfg = SimulationCfg(njmax=20)
+  sim = Simulation(num_envs=1, cfg=sim_cfg, model=model, device=device)
+
+  sensor = sim.mj_model.sensor("robot/joint1_pos")
+  assert sensor.cutoff[0] == 0.01
+
+
+def test_deepcopy_no_double_prefix():
+  """Regression test for #850: deepcopy should not double-prefix sensor name."""
+  cfg = BuiltinSensorCfg(
+    name="joint1_pos",
+    sensor_type="jointpos",
+    obj=ObjRef(type="joint", name="joint1", entity="robot"),
+  )
+  assert cfg.prefixed_name == "robot/joint1_pos"
+
+  cfg_copy = copy.deepcopy(cfg)
+  assert cfg_copy.prefixed_name == "robot/joint1_pos"
+  assert cfg_copy.name == "joint1_pos"
diff --git a/tests/test_camera_sensor.py b/tests/test_camera_sensor.py
new file mode 100644
index 0000000..1d10e49
--- /dev/null
+++ b/tests/test_camera_sensor.py
@@ -0,0 +1,439 @@
+"""Tests for camera_sensor.py and the unified sense pipeline."""
+
+from __future__ import annotations
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.entity import EntityCfg
+from mjlab.scene import Scene, SceneCfg
+from mjlab.sensor import CameraSensorCfg, CameraSensorData
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+SCENE_WITH_CAMERA_XML = """
+  <mujoco>
+    <worldbody>
+      <light pos="0 0 3" dir="0 0 -1"/>
+      <geom name="floor" type="plane" size="10 10 0.1" pos="0 0 0"
+            rgba="0.5 0.5 0.5 1"/>
+      <geom name="red_box" type="box" size="0.5 0.5 0.5" pos="0 0 0.5"
+            rgba="1 0 0 1"/>
+      <camera name="overhead_cam" pos="0 0 3" quat="1 0 0 0"
+              fovy="45" resolution="32 24"/>
+    </worldbody>
+  </mujoco>
+"""
+
+
+def _make_scene_and_sim(
+  device: str,
+  sensors: tuple,
+  xml: str = SCENE_WITH_CAMERA_XML,
+  num_envs: int = 2,
+) -> tuple[Scene, Simulation]:
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(xml))
+  scene_cfg = SceneCfg(
+    num_envs=num_envs,
+    env_spacing=5.0,
+    entities={"world": entity_cfg},
+    sensors=sensors,
+  )
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim = Simulation(num_envs=num_envs, cfg=SimulationCfg(), model=model, device=device)
+  scene.initialize(sim.mj_model, sim.model, sim.data)
+  if scene.sensor_context is not None:
+    sim.set_sensor_context(scene.sensor_context)
+  return scene, sim
+
+
+def test_camera_rgb_shape(device):
+  """RGB data has correct shape [num_envs, height, width, 3]."""
+  cam_cfg = CameraSensorCfg(
+    name="test_cam",
+    camera_name="world/overhead_cam",
+    width=32,
+    height=24,
+    data_types=("rgb",),
+  )
+  scene, sim = _make_scene_and_sim(device, sensors=(cam_cfg,))
+
+  sim.forward()
+  sim.sense()
+  sensor = scene["test_cam"]
+  data = sensor.data
+
+  assert isinstance(data, CameraSensorData)
+  assert data.rgb is not None
+  assert data.rgb.shape == (2, 24, 32, 3)
+  assert data.rgb.dtype == torch.uint8
+  assert data.depth is None
+
+
+def test_camera_depth_shape(device):
+  """Depth data has correct shape [num_envs, height, width]."""
+  cam_cfg = CameraSensorCfg(
+    name="test_cam",
+    camera_name="world/overhead_cam",
+    width=32,
+    height=24,
+    data_types=("depth",),
+  )
+  scene, sim = _make_scene_and_sim(device, sensors=(cam_cfg,))
+
+  sim.forward()
+  sim.sense()
+  data = scene["test_cam"].data
+
+  assert isinstance(data, CameraSensorData)
+  assert data.depth is not None
+  assert data.depth.shape == (2, 24, 32, 1)
+  assert data.depth.dtype == torch.float32
+  assert data.rgb is None
+
+
+def test_camera_rgb_and_depth(device):
+  """Both RGB and depth can be requested simultaneously."""
+  cam_cfg = CameraSensorCfg(
+    name="test_cam",
+    camera_name="world/overhead_cam",
+    width=32,
+    height=24,
+    data_types=("rgb", "depth"),
+  )
+  scene, sim = _make_scene_and_sim(device, sensors=(cam_cfg,))
+
+  sim.forward()
+  sim.sense()
+  data = scene["test_cam"].data
+
+  assert data.rgb is not None
+  assert data.depth is not None
+  assert data.rgb.shape == (2, 24, 32, 3)
+  assert data.depth.shape == (2, 24, 32, 1)
+
+
+def test_camera_create_new(device):
+  """Camera sensor can create a new camera (not wrap existing)."""
+  # XML without any cameras.
+  xml = """
+    <mujoco>
+      <worldbody>
+        <light pos="0 0 3" dir="0 0 -1"/>
+        <geom name="floor" type="plane" size="10 10 0.1"
+              rgba="0.5 0.5 0.5 1"/>
+      </worldbody>
+    </mujoco>
+  """
+  cam_cfg = CameraSensorCfg(
+    name="my_camera",
+    pos=(0.0, 0.0, 3.0),
+    quat=(1.0, 0.0, 0.0, 0.0),
+    fovy=45.0,
+    width=16,
+    height=12,
+    data_types=("rgb",),
+  )
+  scene, sim = _make_scene_and_sim(device, sensors=(cam_cfg,), xml=xml)
+
+  sim.forward()
+  sim.sense()
+  data = scene["my_camera"].data
+
+  assert data.rgb is not None
+  assert data.rgb.shape == (2, 12, 16, 3)
+
+
+def test_camera_rgb_not_all_zeros(device):
+  """RGB data should contain non-zero values when scene has objects."""
+  cam_cfg = CameraSensorCfg(
+    name="test_cam",
+    camera_name="world/overhead_cam",
+    width=32,
+    height=24,
+    data_types=("rgb",),
+  )
+  scene, sim = _make_scene_and_sim(device, sensors=(cam_cfg,))
+
+  sim.forward()
+  sim.sense()
+  data = scene["test_cam"].data
+
+  assert data.rgb is not None
+  # At least some pixels should be non-zero (scene has colored objects).
+  assert data.rgb.any(), "RGB data is all zeros - rendering may have failed"
+
+
+def test_camera_wrap_existing_overrides_fovy(device):
+  """Wrapping an existing camera can override its fovy."""
+  cam_cfg = CameraSensorCfg(
+    name="test_cam",
+    camera_name="world/overhead_cam",
+    width=32,
+    height=24,
+    fovy=90.0,  # Override the camera's fovy
+    data_types=("rgb",),
+  )
+  scene, sim = _make_scene_and_sim(device, sensors=(cam_cfg,))
+
+  # Verify the camera's fovy was updated.
+  cam_id = sim.mj_model.camera("world/overhead_cam").id
+  assert sim.mj_model.cam_fovy[cam_id] == pytest.approx(90.0)
+
+  sim.forward()
+  sim.sense()
+  data = scene["test_cam"].data
+  assert data.rgb is not None
+
+
+@pytest.mark.skipif(
+  not torch.cuda.is_available(), reason="CUDA required for sense graph"
+)
+def test_sense_graph_captured(device):
+  """Verify sense_graph is captured on CUDA."""
+  cam_cfg = CameraSensorCfg(
+    name="test_cam",
+    camera_name="world/overhead_cam",
+    width=16,
+    height=12,
+    data_types=("rgb",),
+  )
+  scene, sim = _make_scene_and_sim(device, sensors=(cam_cfg,))
+
+  # On CUDA with mempool, sense_graph should be captured.
+  if sim.use_cuda_graph:
+    assert sim.sense_graph is not None
+
+
+def test_camera_clone_data(device):
+  """clone_data=True returns independent tensors."""
+  cam_cfg = CameraSensorCfg(
+    name="test_cam",
+    camera_name="world/overhead_cam",
+    width=16,
+    height=12,
+    data_types=("rgb",),
+    clone_data=True,
+  )
+  scene, sim = _make_scene_and_sim(device, sensors=(cam_cfg,))
+
+  sim.forward()
+  sim.sense()
+  data1 = scene["test_cam"].data
+  rgb1 = data1.rgb
+
+  # Invalidate cache and re-read.
+  scene["test_cam"]._invalidate_cache()
+  data2 = scene["test_cam"].data
+  rgb2 = data2.rgb
+
+  # With clone_data=True, the tensors should be different objects.
+  assert rgb1 is not None and rgb2 is not None
+  assert rgb1.data_ptr() != rgb2.data_ptr()
+
+
+def test_camera_sensor_context_created(device):
+  """Scene creates SensorContext when camera sensors are present."""
+  cam_cfg = CameraSensorCfg(
+    name="test_cam",
+    camera_name="world/overhead_cam",
+    width=16,
+    height=12,
+    data_types=("rgb",),
+  )
+  scene, _ = _make_scene_and_sim(device, sensors=(cam_cfg,))
+
+  assert scene.sensor_context is not None
+  assert scene.sensor_context.has_cameras
+
+
+INTRINSIC_CAM_XML = """
+  <mujoco>
+    <worldbody>
+      <light pos="0 0 5" dir="0 0 -1"/>
+      <geom name="floor" type="plane" size="10 10 0.1" pos="0 0 0"
+            rgba="0.5 0.5 0.5 1"/>
+      <geom name="small_box" type="box" size="0.1 0.1 0.1" pos="0 0 0.1"
+            rgba="1 0 0 1"/>
+      <camera name="intrinsic_cam" pos="0 0 5" quat="1 0 0 0"
+              resolution="32 24" sensorsize="0.01 0.01"
+              focal="0.005 0.005"/>
+    </worldbody>
+  </mujoco>
+"""
+
+
+def test_expand_cam_intrinsic_disables_precomputed_rays(device):
+  """Expanding cam_intrinsic disables precomputed rays on the render context."""
+  cam_cfg = CameraSensorCfg(
+    name="test_cam",
+    camera_name="world/intrinsic_cam",
+    width=32,
+    height=24,
+    data_types=("rgb",),
+  )
+  scene, sim = _make_scene_and_sim(device, sensors=(cam_cfg,), xml=INTRINSIC_CAM_XML)
+  assert scene.sensor_context is not None
+
+  # Before expansion: precomputed rays enabled.
+  rc = scene.sensor_context.render_context
+  assert rc.use_precomputed_rays is True
+
+  sim.expand_model_fields(("cam_intrinsic",))
+
+  # After expansion: precomputed rays disabled.
+  rc = scene.sensor_context.render_context
+  assert rc.use_precomputed_rays is False
+
+
+def test_cam_intrinsic_dr_changes_rendered_image(device):
+  """Per-env cam_intrinsic DR produces different images across envs."""
+  cam_cfg = CameraSensorCfg(
+    name="test_cam",
+    camera_name="world/intrinsic_cam",
+    width=32,
+    height=24,
+    data_types=("rgb",),
+  )
+  scene, sim = _make_scene_and_sim(
+    device, sensors=(cam_cfg,), xml=INTRINSIC_CAM_XML, num_envs=2
+  )
+  sim.expand_model_fields(("cam_intrinsic",))
+
+  # Render baseline.
+  sim.forward()
+  sim.sense()
+  baseline = scene["test_cam"].data.rgb.clone()
+
+  # Set env 0 to a very different focal length (5x zoom).
+  cam_id = sim.mj_model.camera("world/intrinsic_cam").id
+  sim.model.cam_intrinsic[0, cam_id, :2] *= 5.0
+
+  sim.forward()
+  sim.sense()
+  after = scene["test_cam"].data.rgb
+
+  # Env 0 should differ (zoomed in), env 1 should be unchanged.
+  assert not torch.equal(after[0], baseline[0]), (
+    "Env 0 image unchanged after cam_intrinsic modification"
+  )
+  assert torch.equal(after[1], baseline[1]), "Env 1 image changed unexpectedly"
+
+
+def test_camera_segmentation_shape(device):
+  """Segmentation data has correct shape [num_envs, height, width, 2]."""
+  cam_cfg = CameraSensorCfg(
+    name="test_cam",
+    camera_name="world/overhead_cam",
+    width=32,
+    height=24,
+    data_types=("segmentation",),
+  )
+  scene, sim = _make_scene_and_sim(device, sensors=(cam_cfg,))
+
+  sim.forward()
+  sim.sense()
+  data = scene["test_cam"].data
+
+  assert isinstance(data, CameraSensorData)
+  assert data.segmentation is not None
+  assert data.segmentation.shape == (2, 24, 32, 2)
+  assert data.segmentation.dtype == torch.int32
+  assert data.rgb is None
+  assert data.depth is None
+
+
+def test_camera_segmentation_content(device):
+  """Segmentation contains typed MuJoCo ids for geom hits and background."""
+  cam_cfg = CameraSensorCfg(
+    name="test_cam",
+    camera_name="world/overhead_cam",
+    width=32,
+    height=24,
+    data_types=("segmentation",),
+  )
+  scene, sim = _make_scene_and_sim(device, sensors=(cam_cfg,))
+
+  sim.forward()
+  sim.sense()
+  seg = scene["test_cam"].data.segmentation
+  assert seg is not None
+
+  seg_np = seg.cpu().numpy()
+  obj_ids = seg_np[..., 0]
+  obj_types = seg_np[..., 1]
+
+  geom_mask = obj_types == int(mujoco.mjtObj.mjOBJ_GEOM)
+  background_mask = obj_types == -1
+
+  assert geom_mask.any(), "Expected at least one geom hit"
+  assert (obj_ids[geom_mask] >= 0).all()
+  assert len(set(obj_ids[geom_mask].flatten().tolist())) > 1
+  if background_mask.any():
+    assert (obj_ids[background_mask] == -1).all()
+
+
+def test_camera_rgb_depth_segmentation(device):
+  """All three data types can be requested simultaneously."""
+  cam_cfg = CameraSensorCfg(
+    name="test_cam",
+    camera_name="world/overhead_cam",
+    width=32,
+    height=24,
+    data_types=("rgb", "depth", "segmentation"),
+  )
+  scene, sim = _make_scene_and_sim(device, sensors=(cam_cfg,))
+
+  sim.forward()
+  sim.sense()
+  data = scene["test_cam"].data
+
+  assert data.rgb is not None
+  assert data.depth is not None
+  assert data.segmentation is not None
+  assert data.rgb.shape == (2, 24, 32, 3)
+  assert data.depth.shape == (2, 24, 32, 1)
+  assert data.segmentation.shape == (2, 24, 32, 2)
+
+
+def test_camera_create_on_parent_body(device):
+  """Camera sensor can create a new camera attached to a body."""
+  xml = """
+    <mujoco>
+      <worldbody>
+        <light pos="0 0 3" dir="0 0 -1"/>
+        <geom name="floor" type="plane" size="10 10 0.1"
+              rgba="0.5 0.5 0.5 1"/>
+        <body name="arm_link" pos="0 0 1">
+          <geom type="box" size="0.1 0.1 0.1" rgba="1 0 0 1"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+  cam_cfg = CameraSensorCfg(
+    name="wrist_cam",
+    parent_body="world/arm_link",
+    pos=(0.0, 0.0, 0.2),
+    quat=(1.0, 0.0, 0.0, 0.0),
+    fovy=45.0,
+    width=16,
+    height=12,
+    data_types=("rgb",),
+  )
+  scene, sim = _make_scene_and_sim(device, sensors=(cam_cfg,), xml=xml)
+
+  sim.forward()
+  sim.sense()
+  data = scene["wrist_cam"].data
+
+  assert isinstance(data, CameraSensorData)
+  assert data.rgb is not None
+  assert data.rgb.shape == (2, 12, 16, 3)
diff --git a/tests/test_circular_buffer.py b/tests/test_circular_buffer.py
new file mode 100644
index 0000000..6f62150
--- /dev/null
+++ b/tests/test_circular_buffer.py
@@ -0,0 +1,268 @@
+"""Tests for CircularBuffer."""
+
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.utils.buffers import CircularBuffer
+
+
+@pytest.fixture
+def device():
+  """Test device fixture."""
+  return get_test_device()
+
+
+def test_circular_buffer_basic_append(device):
+  """Basic append and chronological retrieval (oldest -> newest)."""
+  buffer = CircularBuffer(max_len=3, batch_size=2, device=device)
+
+  buffer.append(torch.tensor([[1.0, 2.0], [3.0, 4.0]], device=device))
+  buffer.append(torch.tensor([[5.0, 6.0], [7.0, 8.0]], device=device))
+  buffer.append(torch.tensor([[9.0, 10.0], [11.0, 12.0]], device=device))
+
+  result = buffer.buffer
+  assert result.shape == (2, 3, 2)
+  # Oldest to newest.
+  assert torch.allclose(
+    result[0], torch.tensor([[1.0, 2.0], [5.0, 6.0], [9.0, 10.0]], device=device)
+  )
+  assert torch.allclose(
+    result[1], torch.tensor([[3.0, 4.0], [7.0, 8.0], [11.0, 12.0]], device=device)
+  )
+
+
+def test_circular_buffer_overwrite(device):
+  """Overwrites oldest once capacity reached."""
+  buffer = CircularBuffer(max_len=2, batch_size=1, device=device)
+
+  buffer.append(torch.tensor([[1.0]], device=device))
+  buffer.append(torch.tensor([[2.0]], device=device))
+  buffer.append(torch.tensor([[3.0]], device=device))  # Overwrites first.
+
+  result = buffer.buffer
+  assert result.shape == (1, 2, 1)
+  assert torch.allclose(result[0], torch.tensor([[2.0], [3.0]], device=device))
+
+
+def test_circular_buffer_reset_single_batch(device):
+  """Reset clears values and counters for specified batch rows."""
+  buffer = CircularBuffer(max_len=2, batch_size=3, device=device)
+
+  buffer.append(torch.tensor([[1.0], [2.0], [3.0]], device=device))
+  buffer.append(torch.tensor([[4.0], [5.0], [6.0]], device=device))
+
+  # Reset only batch index 1.
+  buffer.reset(batch_ids=torch.tensor([1], device=device))
+
+  result = buffer.buffer
+  # Oldest-to-newest for each batch row.
+  assert result[0, 0, 0] == 1.0
+  assert result[1, 0, 0] == 0.0  # Reset backfilled to zeros for that row.
+  assert result[2, 0, 0] == 3.0
+
+  # current_length reflects reset: rows 0 and 2 had 2 pushes, row 1 is 0.
+  cl = buffer.current_length
+  assert torch.equal(cl.cpu(), torch.tensor([2, 0, 2]))
+
+
+def test_circular_buffer_first_append_fills(device):
+  """First append back-fills whole history for each batch row."""
+  buffer = CircularBuffer(max_len=3, batch_size=2, device=device)
+  buffer.append(torch.tensor([[1.0], [2.0]], device=device))
+
+  result = buffer.buffer
+  assert torch.allclose(result[0], torch.tensor([[1.0], [1.0], [1.0]], device=device))
+  assert torch.allclose(result[1], torch.tensor([[2.0], [2.0], [2.0]], device=device))
+
+  # And current_length reflects valid frames so far.
+  cl = buffer.current_length
+  assert torch.equal(cl.cpu(), torch.tensor([1, 1]))
+
+
+def test_current_length_counts_and_clamps(device):
+  """current_length counts per-batch valid frames and clamps to max_len."""
+  buffer = CircularBuffer(max_len=4, batch_size=3, device=device)
+
+  # Two appends -> length 2 everywhere.
+  for _ in range(2):
+    buffer.append(torch.arange(3, dtype=torch.float32, device=device).unsqueeze(-1))
+
+  assert torch.equal(buffer.current_length.cpu(), torch.tensor([2, 2, 2]))
+
+  # Reset middle row -> it becomes 0.
+  buffer.reset(batch_ids=[1])
+  assert torch.equal(buffer.current_length.cpu(), torch.tensor([2, 0, 2]))
+
+  # One more append -> rows [0,2] become 3; row 1 becomes 1.
+  buffer.append(torch.arange(3, dtype=torch.float32, device=device).unsqueeze(-1))
+  assert torch.equal(buffer.current_length.cpu(), torch.tensor([3, 1, 3]))
+
+  # Fill beyond capacity -> clamp to max_len.
+  for _ in range(5):
+    buffer.append(torch.arange(3, dtype=torch.float32, device=device).unsqueeze(-1))
+  assert torch.equal(buffer.current_length.cpu(), torch.tensor([4, 4, 4]))
+
+
+def test_reset_all_none_path(device):
+  """reset(None) zeros the entire buffer and counters without indexing."""
+  buffer = CircularBuffer(max_len=3, batch_size=2, device=device)
+  buffer.append(torch.tensor([[1.0], [2.0]], device=device))
+  buffer.append(torch.tensor([[3.0], [4.0]], device=device))
+
+  buffer.reset()  # None -> reset all.
+
+  # Counters are zero.
+  assert torch.equal(buffer.current_length.cpu(), torch.tensor([0, 0]))
+  # Buffer zeros (safe to read even after reset because storage exists).
+  result = buffer.buffer
+  assert torch.count_nonzero(result) == 0
+
+
+def test_getitem_lifo_and_clamp(device):
+  """__getitem__ returns lagged frames per-batch (LIFO), clamping when needed."""
+  buffer = CircularBuffer(max_len=3, batch_size=2, device=device)
+
+  buffer.append(torch.tensor([[1.0], [10.0]], device=device))  # t0
+  buffer.append(torch.tensor([[2.0], [20.0]], device=device))  # t1
+  buffer.append(torch.tensor([[3.0], [30.0]], device=device))  # t2
+
+  # Lag 0 for batch 0 (-> 3), lag 2 for batch 1 (-> oldest 10).
+  out = buffer[torch.tensor([0, 2], device=device)]
+  assert torch.allclose(out, torch.tensor([[3.0], [10.0]], device=device))
+
+  # Clamp: huge lag for batch 0 -> oldest (1), lag 1 for batch 1 -> 20.
+  out = buffer[torch.tensor([99, 1], device=device)]
+  assert torch.allclose(out, torch.tensor([[1.0], [20.0]], device=device))
+
+
+def test_backfill_after_per_batch_reset(device):
+  """After resetting a row, the next append back-fills its entire history for that row."""
+  buffer = CircularBuffer(max_len=3, batch_size=2, device=device)
+
+  buffer.append(torch.tensor([[1.0], [10.0]], device=device))  # t0
+  buffer.append(torch.tensor([[2.0], [20.0]], device=device))  # t1
+
+  # Reset only batch row 1; row 0 remains with 2 valid frames.
+  buffer.reset(batch_ids=[1])
+  assert torch.equal(buffer.current_length.cpu(), torch.tensor([2, 0]))
+
+  # Next append: row 0 gets new value; row 1 is "first push" -> back-filled.
+  buffer.append(torch.tensor([[3.0], [99.0]], device=device))  # t2
+
+  hist = buffer.buffer  # shape (2, 3, 1)
+  # Row 0 keeps real chronology [1, 2, 3].
+  assert torch.allclose(
+    hist[0].squeeze(-1), torch.tensor([1.0, 2.0, 3.0], device=device)
+  )
+  # Row 1 is back-filled to all 99s.
+  assert torch.allclose(
+    hist[1].squeeze(-1), torch.tensor([99.0, 99.0, 99.0], device=device)
+  )
+
+
+def test_backfill_multidimensional_data(device):
+  """First-push backfill works for >2D data whose trailing dims differ from batch.
+
+  Regression for #1045: the backfill broadcast hard-coded a 3D condition shape,
+  which misaligned the batch axis with a trailing axis when num_targets != batch.
+  Here batch_size=4 but the trailing axis is 2, so the buggy broadcast raised a
+  4-vs-2 mismatch.
+  """
+  batch_size, num_targets, num_channels = 4, 2, 3
+  buffer = CircularBuffer(max_len=3, batch_size=batch_size, device=device)
+
+  data = torch.arange(
+    batch_size * num_targets * num_channels, dtype=torch.float32, device=device
+  ).reshape(batch_size, num_targets, num_channels)
+  buffer.append(data)
+
+  hist = buffer.buffer  # (batch, max_len, num_targets, num_channels)
+  assert hist.shape == (batch_size, 3, num_targets, num_channels)
+  # First push backfills every history slot with the same frame per batch row.
+  for t in range(3):
+    assert torch.allclose(hist[:, t], data)
+
+
+def test_errors_and_types(device):
+  """Error paths: wrong batch, pre-append access, and bad key size."""
+  buffer = CircularBuffer(max_len=2, batch_size=2, device=device)
+
+  # Wrong batch size on append.
+  with pytest.raises(ValueError):
+    buffer.append(torch.tensor([[1.0]], device=device))  # batch_size=1 wrong
+
+  # buffer property before first append.
+  with pytest.raises(RuntimeError):
+    _ = CircularBuffer(max_len=1, batch_size=1, device=device).buffer
+
+  # __getitem__ before any valid pushes.
+  with pytest.raises(RuntimeError):
+    _ = buffer[torch.tensor([0, 0], device=device)]
+
+  # Now append once so storage exists and counters > 0.
+  buffer.append(torch.tensor([[1.0], [2.0]], device=device))
+
+  # __getitem__ with wrong key length.
+  with pytest.raises(ValueError):
+    _ = buffer[torch.tensor([0], device=device)]
+
+
+def test_dtype_and_device_preserved(device):
+  """Buffer preserves dtype and device."""
+  buffer = CircularBuffer(max_len=2, batch_size=2, device=device)
+  x = torch.tensor([[1.0], [2.0]], dtype=torch.float32, device=device)
+  buffer.append(x)
+  assert buffer.buffer.dtype == torch.float32
+  assert buffer.buffer.device.type == torch.device(device).type
+
+
+def test_backfill_only_touches_given_rows(device):
+  """backfill writes one frame into all slots of given rows, no pointer advance."""
+  buffer = CircularBuffer(max_len=3, batch_size=3, device=device)
+  buffer.append(torch.tensor([[1.0], [10.0], [100.0]], device=device))
+  buffer.append(torch.tensor([[2.0], [20.0], [200.0]], device=device))
+  buffer.append(torch.tensor([[3.0], [30.0], [300.0]], device=device))
+
+  buffer.reset(batch_ids=torch.tensor([1], device=device))
+  data = torch.tensor([[-1.0], [99.0], [-1.0]], device=device)
+  buffer.backfill(data, torch.tensor([1], device=device))
+
+  result = buffer.buffer
+  assert torch.allclose(
+    result[0].flatten(), torch.tensor([1.0, 2.0, 3.0], device=device)
+  )
+  assert torch.allclose(
+    result[1].flatten(), torch.tensor([99.0, 99.0, 99.0], device=device)
+  )
+  assert torch.allclose(
+    result[2].flatten(), torch.tensor([100.0, 200.0, 300.0], device=device)
+  )
+  assert buffer.current_length.tolist() == [3, 1, 3]
+
+  # Subsequent appends treat the backfilled row normally.
+  buffer.append(torch.tensor([[4.0], [40.0], [400.0]], device=device))
+  result = buffer.buffer
+  assert torch.allclose(
+    result[1].flatten(), torch.tensor([99.0, 99.0, 40.0], device=device)
+  )
+  assert buffer.current_length.tolist() == [3, 2, 3]
+
+
+def test_backfill_uninitialized_raises(device):
+  buffer = CircularBuffer(max_len=2, batch_size=2, device=device)
+  with pytest.raises(RuntimeError, match="not initialized"):
+    buffer.backfill(torch.zeros(2, 1, device=device), torch.tensor([0], device=device))
+
+
+def test_getitem_lag_clamps_to_oldest_after_wrap(device):
+  buffer = CircularBuffer(max_len=2, batch_size=1, device=device)
+  for v in [1.0, 2.0, 3.0]:
+    buffer.append(torch.tensor([[v]], device=device))
+
+  # Retained frames: [2, 3] (num_pushes exceeds max_len).
+  assert buffer[torch.tensor([0], device=device)].flatten().item() == 3.0
+  assert buffer[torch.tensor([1], device=device)].flatten().item() == 2.0
+  # A lag beyond the retained history clamps to the oldest frame instead of
+  # wrapping around to a newer one.
+  assert buffer[torch.tensor([2], device=device)].flatten().item() == 2.0
diff --git a/tests/test_command_manager.py b/tests/test_command_manager.py
new file mode 100644
index 0000000..86e60a5
--- /dev/null
+++ b/tests/test_command_manager.py
@@ -0,0 +1,179 @@
+"""Tests for command manager."""
+
+from dataclasses import dataclass
+from unittest.mock import Mock
+
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.envs import ManagerBasedRlEnv
+from mjlab.managers.command_manager import CommandTerm, CommandTermCfg
+from mjlab.tasks.cartpole.cartpole_env_cfg import cartpole_balance_env_cfg
+from mjlab.tasks.tracking.mdp.commands import MotionCommand
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+class CounterCommand(CommandTerm):
+  """Stateful command term: a per-env counter ticked by _update_command."""
+
+  def __init__(self, cfg, env):
+    super().__init__(cfg, env)
+    self.ticks = torch.zeros(self.num_envs, dtype=torch.long, device=self.device)
+
+  @property
+  def command(self) -> torch.Tensor:
+    return self.ticks.unsqueeze(-1).float()
+
+  def _update_metrics(self) -> None:
+    pass
+
+  def _resample_command(self, env_ids: torch.Tensor) -> None:
+    self.ticks[env_ids] = 0
+
+  def _update_command(self, env_ids: torch.Tensor | None = None) -> None:
+    if env_ids is None:
+      self.ticks += 1
+    else:
+      self.ticks[env_ids] += 1
+
+
+@dataclass(kw_only=True)
+class CounterCommandCfg(CommandTermCfg):
+  resampling_time_range: tuple[float, float] = (1e9, 1e9)
+
+  def build(self, env) -> CounterCommand:
+    return CounterCommand(self, env)
+
+
+@pytest.fixture
+def counter_env(device):
+  cfg = cartpole_balance_env_cfg()
+  cfg.scene.num_envs = 4
+  cfg.commands = {"counter": CounterCommandCfg()}
+  env = ManagerBasedRlEnv(cfg=cfg, device=device)
+  yield env
+  env.close()
+
+
+def test_partial_reset_does_not_advance_other_envs(counter_env):
+  env = counter_env
+  term = env.command_manager.get_term("counter")
+  assert isinstance(term, CounterCommand)
+
+  # Full reset: every env is resampled (counter zeroed) then ticked once.
+  env.reset()
+  assert term.ticks.tolist() == [1, 1, 1, 1]
+
+  action = torch.zeros((env.num_envs, 1), device=env.device)
+  env.step(action)
+  assert term.ticks.tolist() == [2, 2, 2, 2]
+
+  # Partial reset: only env 1 is resampled and ticked. Before the fix for
+  # issue #1138 the other envs advanced too (to 3).
+  env.reset(env_ids=torch.tensor([1], dtype=torch.int64, device=env.device))
+  assert term.ticks.tolist() == [2, 1, 2, 2]
+
+  # The next step advances everyone by exactly one.
+  env.step(action)
+  assert term.ticks.tolist() == [3, 2, 3, 3]
+
+
+def test_old_style_update_command_raises(counter_env):
+  """Terms with the old zero-arg _update_command fail fast at construction."""
+
+  class OldStyleCommand(CounterCommand):
+    def _update_command(self) -> None:  # type: ignore[override]
+      self.ticks += 1
+
+  @dataclass(kw_only=True)
+  class OldStyleCommandCfg(CounterCommandCfg):
+    def build(self, env) -> "OldStyleCommand":
+      return OldStyleCommand(self, env)
+
+  with pytest.raises(TypeError, match="env_ids"):
+    OldStyleCommandCfg().build(counter_env)
+
+
+def _make_motion_command_stub(time_steps, total, sampling_mode="uniform"):
+  """A stub with just enough state to drive MotionCommand._update_command."""
+  cmd = Mock()
+  cmd.time_steps = torch.tensor(time_steps, dtype=torch.long)
+  cmd.motion = Mock()
+  cmd.motion.time_step_total = total
+  cmd.cfg = Mock()
+  cmd.cfg.sampling_mode = sampling_mode
+  cmd.cfg.adaptive_alpha = 0.5
+  cmd.bin_failed_count = torch.tensor([1.0, 1.0])
+  cmd._current_bin_failed = torch.tensor([4.0, 4.0])
+  cmd._pending_forward = False
+  cmd._resample_command = Mock(
+    side_effect=lambda ids: setattr(cmd, "_pending_forward", True)
+  )
+  return cmd
+
+
+def test_motion_command_update_scopes_time_advance():
+  cmd = _make_motion_command_stub([2, 5, 7], total=100)
+  MotionCommand._update_command(cmd, env_ids=torch.tensor([1]))
+  assert cmd.time_steps.tolist() == [2, 6, 7]
+  cmd._resample_command.assert_not_called()
+  cmd.update_relative_body_poses.assert_called_once()
+
+  MotionCommand._update_command(cmd, env_ids=None)
+  assert cmd.time_steps.tolist() == [3, 7, 8]
+
+
+def test_motion_command_update_resamples_on_wraparound():
+  cmd = _make_motion_command_stub([2, 9], total=10)
+  MotionCommand._update_command(cmd, env_ids=torch.tensor([1]))
+  # Env 1 wrapped past the end of the motion and must be resampled; env 0
+  # is untouched.
+  (wrap_ids,), _ = cmd._resample_command.call_args
+  assert wrap_ids.tolist() == [1]
+  assert cmd.time_steps[0].item() == 2
+  cmd._env.sim.forward.assert_called_once()
+
+
+def test_motion_command_ema_folds_only_on_step_update():
+  cmd = _make_motion_command_stub([2, 5], total=100, sampling_mode="adaptive")
+  MotionCommand._update_command(cmd, env_ids=torch.tensor([0]))
+  # Reset-scoped update: EMA untouched, pending failure counts preserved.
+  assert cmd.bin_failed_count.tolist() == [1.0, 1.0]
+  assert cmd._current_bin_failed.tolist() == [4.0, 4.0]
+
+  MotionCommand._update_command(cmd, env_ids=None)
+  # Per-step update: EMA folds the counts and clears them.
+  assert cmd.bin_failed_count.tolist() == [2.5, 2.5]
+  assert cmd._current_bin_failed.tolist() == [0.0, 0.0]
+
+
+def test_motion_command_gui_reset_forwards_before_pose_update():
+  """apply_gui_reset must refresh kinematics between the state write and
+  update_relative_body_poses (viewer forwards only after it returns)."""
+  calls = []
+  cmd = Mock()
+  cmd._scrubber_handles = (Mock(value=5),)
+  cmd.reset_to_frame = lambda ids, frame: calls.append("reset_to_frame")
+  cmd._env.sim.forward = lambda: calls.append("forward")
+  cmd.update_relative_body_poses = lambda: calls.append("update_poses")
+
+  assert MotionCommand.apply_gui_reset(cmd, torch.tensor([0])) is True
+  assert calls == ["reset_to_frame", "forward", "update_poses"]
+
+
+def test_motion_command_timer_resample_triggers_forward():
+  """A timer-expiry resample (flag set before _update_command) forwards."""
+  cmd = _make_motion_command_stub([2, 5], total=100)
+  cmd._pending_forward = True  # As set by a compute-path _resample_command.
+  MotionCommand._update_command(cmd, env_ids=None)
+  cmd._env.sim.forward.assert_called_once()
+  assert cmd._pending_forward is False
+
+  cmd._env.sim.forward.reset_mock()
+  MotionCommand._update_command(cmd, env_ids=None)
+  cmd._env.sim.forward.assert_not_called()
diff --git a/tests/test_contact_sensor.py b/tests/test_contact_sensor.py
new file mode 100644
index 0000000..be02fd5
--- /dev/null
+++ b/tests/test_contact_sensor.py
@@ -0,0 +1,1182 @@
+"""Tests for contact_sensor.py."""
+
+from __future__ import annotations
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device, load_fixture_xml
+
+from mjlab.entity import EntityCfg
+from mjlab.scene import Scene, SceneCfg
+from mjlab.sensor.contact_sensor import ContactMatch, ContactSensorCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+##
+# Test XML models.
+##
+
+FALLING_BOX_XML = """
+<mujoco>
+  <worldbody>
+    <body name="ground" pos="0 0 0">
+      <geom name="ground_geom" type="plane" size="5 5 0.1" rgba="0.5 0.5 0.5 1"/>
+    </body>
+    <body name="box" pos="0 0 0.5">
+      <freejoint name="box_joint"/>
+      <geom name="box_geom" type="box" size="0.1 0.1 0.1" rgba="0.8 0.3 0.3 1"
+        mass="1.0"/>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+BIPED_XML = load_fixture_xml("biped")
+
+SIMPLE_ROBOT_XML = """
+<mujoco>
+  <worldbody>
+    <body name="ground" pos="0 0 0">
+      <geom name="ground_geom" type="plane" size="5 5 0.1"/>
+    </body>
+    <body name="robot" pos="0 0 0.3">
+      <freejoint name="robot_joint"/>
+      <geom name="trunk_collision" type="box" size="0.2 0.15 0.1" mass="2.0"/>
+      <geom name="head_collision" type="sphere" size="0.08" pos="0.25 0 0.1"
+      mass="0.5"/>
+      <body name="leg1" pos="0.1 0.1 -0.1">
+        <geom name="leg1_thigh_collision1" type="capsule" size="0.02"
+          fromto="0 0 0 0 0 -0.1"/>
+        <geom name="leg1_thigh_collision2" type="capsule" size="0.02"
+          fromto="0 0 -0.05 0 0 -0.15"/>
+        <geom name="leg1_foot_collision" type="sphere" size="0.03" pos="0 0 -0.2"/>
+      </body>
+      <body name="leg2" pos="-0.1 0.1 -0.1">
+        <geom name="leg2_thigh_collision1" type="capsule" size="0.02"
+          fromto="0 0 0 0 0 -0.1"/>
+        <geom name="leg2_thigh_collision2" type="capsule" size="0.02"
+          fromto="0 0 -0.05 0 0 -0.15"/>
+        <geom name="leg2_foot_collision" type="sphere" size="0.03" pos="0 0 -0.2"/>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+##
+# Fixtures.
+##
+
+
+@pytest.fixture(scope="module")
+def device():
+  """Test device fixture."""
+  return get_test_device()
+
+
+##
+# Helper functions.
+##
+
+
+def create_scene_with_sensor(
+  xml: str,
+  entity_name: str,
+  sensor_cfg: ContactSensorCfg,
+  device: str,
+  num_envs: int = 2,
+  njmax: int = 75,
+) -> tuple[Scene, Simulation]:
+  """Helper to create a complete test environment with contact sensor.
+
+  Sets up a scene with the specified entity and contact sensor configuration,
+  compiles the model, creates a simulation, and initializes everything together.
+  Returns the scene and simulation objects for test manipulation and assertions."""
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(xml))
+
+  scene_cfg = SceneCfg(
+    num_envs=num_envs,
+    env_spacing=3.0,
+    entities={entity_name: entity_cfg},
+    sensors=(sensor_cfg,),
+  )
+
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim_cfg = SimulationCfg(njmax=njmax)
+  sim = Simulation(num_envs=num_envs, cfg=sim_cfg, model=model, device=device)
+  scene.initialize(sim.mj_model, sim.model, sim.data)
+
+  return scene, sim
+
+
+def step_and_settle(sim: Simulation, num_steps: int = 30):
+  """Run simulation steps to allow physics to stabilize and contacts to form.
+
+  Useful after placing objects to let them fall under gravity and establish
+  stable contact with ground or other objects before testing contact detection."""
+  for _ in range(num_steps):
+    sim.step()
+
+
+##
+# Basic contact detection tests.
+##
+
+
+def test_basic_contact_detection(device):
+  """Verify that contact sensors detect collisions between a falling box and ground.
+
+  Tests that when a box is placed just above ground and simulation steps,
+  the contact sensor correctly reports contact forces and found flags."""
+  contact_sensor_cfg = ContactSensorCfg(
+    name="box_contact",
+    primary=ContactMatch(mode="geom", pattern="box_geom", entity="box"),
+    secondary=None,
+    fields=("found", "force"),
+  )
+
+  scene, sim = create_scene_with_sensor(
+    FALLING_BOX_XML, "box", contact_sensor_cfg, device
+  )
+
+  sensor = scene["box_contact"]
+  box_entity = scene["box"]
+
+  # Place box on ground and let it settle.
+  root_state = torch.zeros((2, 13), device=sim.device)
+  root_state[:, 2] = 0.11  # Just above ground
+  root_state[:, 3] = 1.0
+  box_entity.write_root_state_to_sim(root_state)
+
+  step_and_settle(sim)
+
+  data = sensor.data
+
+  # Basic field presence and shape checks.
+  assert data.found is not None
+  assert data.force is not None
+  assert data.found.shape == (2, 1)  # 2 envs, 1 slot
+  assert data.force.shape[-1] == 3
+
+  # Contact should be detected.
+  assert torch.any(data.found > 0)
+
+  # Force should be non-zero when contact is detected.
+  if torch.any(data.found > 0):
+    contact_forces = data.force[data.found > 0]
+    assert torch.any(torch.abs(contact_forces) > 0)
+
+
+def test_contact_fields(device):
+  """Verify all contact sensor output fields have correct shapes and values.
+
+  Tests that force, torque, dist, pos, and normal fields are properly populated
+  with appropriate dimensionality (3D vectors for force/torque/pos/normal, scalar for dist)."""
+  contact_sensor_cfg = ContactSensorCfg(
+    name="box_contact",
+    primary=ContactMatch(mode="geom", pattern="box_geom", entity="box"),
+    secondary=None,
+    fields=("found", "force", "torque", "dist", "pos", "normal"),
+  )
+
+  scene, sim = create_scene_with_sensor(
+    FALLING_BOX_XML, "box", contact_sensor_cfg, device
+  )
+
+  sensor = scene["box_contact"]
+  box_entity = scene["box"]
+
+  root_state = torch.zeros((2, 13), device=sim.device)
+  root_state[:, 2] = 0.105
+  root_state[:, 3] = 1.0
+  box_entity.write_root_state_to_sim(root_state)
+
+  step_and_settle(sim, num_steps=10)
+
+  data = sensor.data
+
+  # Verify all fields are present with correct shapes.
+  assert data.found is not None
+  assert data.force is not None
+  assert data.torque is not None
+  assert data.dist is not None
+  assert data.pos is not None
+  assert data.normal is not None
+
+  assert data.force.shape[-1] == 3
+  assert data.torque.shape[-1] == 3
+  assert data.pos.shape[-1] == 3
+  assert data.normal.shape[-1] == 3
+  assert len(data.dist.shape) == 2
+
+
+##
+# Pattern matching and multi-slot tests.
+##
+
+
+def test_multi_slot_pattern_matching(device):
+  """Verify pattern lists create separate tracking slots for each matched geom.
+
+  When passing a list of patterns like ["left_foot_geom", "right_foot_geom"],
+  the sensor should create independent contact tracking for each foot,
+  allowing simultaneous monitoring of multiple contact points."""
+  feet_sensor_cfg = ContactSensorCfg(
+    name="feet_contact",
+    primary=ContactMatch(
+      mode="geom",
+      pattern=("left_foot_geom", "right_foot_geom"),
+      entity="biped",
+    ),
+    secondary=None,
+    fields=("found", "force"),
+    track_air_time=True,
+  )
+
+  scene, sim = create_scene_with_sensor(BIPED_XML, "biped", feet_sensor_cfg, device)
+
+  sensor = scene["feet_contact"]
+  biped_entity = scene["biped"]
+
+  # Place biped on ground.
+  root_state = torch.zeros((2, 13), device=sim.device)
+  root_state[:, 2] = 0.25
+  root_state[:, 3] = 1.0
+  biped_entity.write_root_state_to_sim(root_state)
+
+  step_and_settle(sim, num_steps=20)
+
+  data = sensor.data
+
+  # Should have 2 slots (one per foot).
+  assert data.found.shape == (2, 2)
+  assert data.force.shape == (2, 2, 3)
+
+  # Air time should be tracked.
+  assert hasattr(data, "current_air_time")
+  assert data.current_air_time.shape == (2, 2)
+
+
+def test_regex_pattern_matching(device):
+  """Verify regex patterns correctly match multiple geoms with similar names.
+
+  Tests that a pattern like ".*foot_geom$" matches all geoms ending with
+  "foot_geom", enabling efficient batch configuration of similar contact points.
+  Also verifies regex patterns work correctly for actual contact detection."""
+  # Match all foot geoms using regex.
+  regex_sensor_cfg = ContactSensorCfg(
+    name="all_feet_contact",
+    primary=ContactMatch(
+      mode="geom",
+      pattern=r".*foot_geom$",
+      entity="biped",
+    ),
+    secondary=None,
+    fields=("found", "force"),
+  )
+
+  scene, sim = create_scene_with_sensor(BIPED_XML, "biped", regex_sensor_cfg, device)
+
+  sensor = scene["all_feet_contact"]
+  biped_entity = scene["biped"]
+
+  # Should match both left_foot_geom and right_foot_geom.
+  assert sensor.data.found.shape == (2, 2)
+
+  # Place biped on ground to verify regex-matched geoms detect contacts.
+  root_state = torch.zeros((2, 13), device=sim.device)
+  root_state[:, 2] = 0.24  # Low enough for feet to touch ground
+  root_state[:, 3] = 1.0
+  biped_entity.write_root_state_to_sim(root_state)
+
+  # Run simulation and update scene to invalidate cache.
+  for _ in range(20):
+    sim.step()
+    scene.update(dt=sim.cfg.mujoco.timestep)
+
+  data = sensor.data
+  # Both feet should detect ground contact.
+  assert torch.any(data.found > 0)
+  # Force field should be present (may have small values).
+  assert data.force is not None
+  assert data.force.shape == (2, 2, 3)
+
+
+##
+# Reduction mode tests.
+##
+
+
+@pytest.mark.parametrize(
+  "reduce_mode",
+  ["none", "mindist", "maxforce", "netforce"],
+)
+def test_reduce_modes(device, reduce_mode):
+  """Verify reduction modes correctly aggregate multiple simultaneous contacts.
+
+  Tests "none" (no filtering), "mindist" (closest contact), "maxforce" (strongest),
+  and "netforce" (sum all forces) modes for selecting/combining contact data
+  when multiple contacts occur on the same geom."""
+  sensor_cfg = ContactSensorCfg(
+    name="box_contact",
+    primary=ContactMatch(mode="geom", pattern="box_geom", entity="box"),
+    secondary=None,
+    fields=("force",),
+    reduce=reduce_mode,
+    num_slots=1,
+  )
+
+  scene, _ = create_scene_with_sensor(FALLING_BOX_XML, "box", sensor_cfg, device)
+
+  sensor = scene["box_contact"]
+  data = sensor.data
+
+  # All reduction modes return 3D shape for force field.
+  assert len(data.force.shape) == 3
+  assert data.force.shape[-1] == 3  # Force is always a 3D vector
+
+
+def test_reduce_modes_multiple_contacts(device):
+  """Test reduction modes with multiple simultaneous contacts."""
+  feet_sensor_cfg = ContactSensorCfg(
+    name="feet_contact",
+    primary=ContactMatch(
+      mode="geom",
+      pattern=("left_foot_geom", "right_foot_geom"),
+      entity="biped",
+    ),
+    secondary=None,
+    fields=("found", "force", "dist"),
+    reduce="mindist",
+    num_slots=1,
+  )
+
+  scene, sim = create_scene_with_sensor(BIPED_XML, "biped", feet_sensor_cfg, device)
+
+  sensor = scene["feet_contact"]
+  biped_entity = scene["biped"]
+
+  # Place biped on ground.
+  root_state = torch.zeros((2, 13), device=sim.device)
+  root_state[:, 2] = 0.25
+  root_state[:, 3] = 1.0
+  biped_entity.write_root_state_to_sim(root_state)
+
+  step_and_settle(sim, num_steps=20)
+
+  data = sensor.data
+
+  # With reduce="mindist" and num_slots=1, should have 2 slots (2 primaries × 1 slot).
+  assert data.found.shape == (2, 2)
+  assert data.force.shape == (2, 2, 3)
+
+
+##
+# Exclude pattern tests.
+##
+
+
+def test_exclude_exact_names(device):
+  """Verify exact name exclusion removes specific geoms from contact detection.
+
+  Tests the ergonomic feature where passing exact geom names like
+  ("leg1_foot_collision", "leg2_foot_collision") excludes only those specific
+  geoms without needing complex regex patterns."""
+  # Sensor that excludes foot collisions by exact names.
+  nonfoot_sensor_cfg = ContactSensorCfg(
+    name="nonfoot_contact",
+    primary=ContactMatch(
+      mode="geom",
+      pattern=r".*_collision\d*$",  # Match all collision geoms
+      entity="robot",
+      exclude=("leg1_foot_collision", "leg2_foot_collision"),  # Exact names
+    ),
+    secondary=None,
+    fields=("found",),
+  )
+
+  scene, _ = create_scene_with_sensor(
+    SIMPLE_ROBOT_XML, "robot", nonfoot_sensor_cfg, device
+  )
+
+  sensor = scene["nonfoot_contact"]
+
+  # Should detect 6 geoms: trunk, head, 2x leg1_thigh, 2x leg2_thigh.
+  # Foot collisions should be excluded.
+  assert sensor.data.found.shape == (2, 6)
+
+
+def test_exclude_regex_pattern(device):
+  """Verify regex exclusion patterns filter out groups of similarly-named geoms.
+
+  Tests that patterns like ".*thigh_collision\\d+" can exclude all thigh
+  collision geoms while preserving other collision geoms for contact detection."""
+  # Sensor that excludes all thigh collisions using regex.
+  no_thigh_sensor_cfg = ContactSensorCfg(
+    name="no_thigh_contact",
+    primary=ContactMatch(
+      mode="geom",
+      pattern=r".*_collision\d*$",
+      entity="robot",
+      exclude=(r".*thigh_collision\d+",),  # Regex pattern
+    ),
+    secondary=None,
+    fields=("found",),
+  )
+
+  scene, _ = create_scene_with_sensor(
+    SIMPLE_ROBOT_XML, "robot", no_thigh_sensor_cfg, device
+  )
+
+  sensor = scene["no_thigh_contact"]
+
+  # Should detect 4 geoms: trunk, head, 2x foot (thighs excluded by regex).
+  assert sensor.data.found.shape == (2, 4)
+
+
+def test_exclude_mixed_patterns(device):
+  """Verify exact names and regex patterns can be mixed in exclude lists.
+
+  Tests that exclude tuples can contain both exact names ("trunk_collision")
+  and regex patterns (".*foot_collision") simultaneously, with automatic
+  detection of which exclusion method to use for each entry."""
+  mixed_exclude_cfg = ContactSensorCfg(
+    name="mixed_exclude",
+    primary=ContactMatch(
+      mode="geom",
+      pattern=r".*_collision\d*$",
+      entity="robot",
+      exclude=(
+        "trunk_collision",  # Exact name
+        r".*foot_collision",  # Regex pattern
+      ),
+    ),
+    secondary=None,
+    fields=("found",),
+  )
+
+  scene, _ = create_scene_with_sensor(
+    SIMPLE_ROBOT_XML, "robot", mixed_exclude_cfg, device
+  )
+
+  sensor = scene["mixed_exclude"]
+
+  # Should detect 5 geoms: head, 4x thigh (trunk and feet excluded).
+  assert sensor.data.found.shape == (2, 5)
+
+
+##
+# Body and subtree mode tests.
+##
+
+
+def test_body_mode_contacts(device):
+  """Test contact detection with body mode."""
+  body_sensor_cfg = ContactSensorCfg(
+    name="body_contact",
+    primary=ContactMatch(mode="body", pattern="base", entity="biped"),
+    secondary=None,
+    fields=("found",),
+  )
+
+  scene, _ = create_scene_with_sensor(BIPED_XML, "biped", body_sensor_cfg, device)
+
+  sensor = scene["body_contact"]
+  data = sensor.data
+
+  # Should match the base body.
+  assert data.found.shape[1] == 1
+
+
+def test_subtree_mode_contacts(device):
+  """Test contact detection with subtree mode."""
+  subtree_sensor_cfg = ContactSensorCfg(
+    name="subtree_contact",
+    primary=ContactMatch(mode="subtree", pattern="base", entity="biped"),
+    secondary=None,
+    fields=("found",),
+  )
+
+  scene, sim = create_scene_with_sensor(BIPED_XML, "biped", subtree_sensor_cfg, device)
+
+  sensor = scene["subtree_contact"]
+  biped_entity = scene["biped"]
+
+  # Place biped on ground.
+  root_state = torch.zeros((2, 13), device=sim.device)
+  root_state[:, 2] = 0.2  # Low enough for feet to touch
+  root_state[:, 3] = 1.0
+  biped_entity.write_root_state_to_sim(root_state)
+
+  step_and_settle(sim, num_steps=30)
+
+  data = sensor.data
+
+  # Subtree includes base and all children (feet), so contacts should be detected.
+  assert torch.any(data.found > 0)
+
+
+##
+# Air time tracking tests.
+##
+
+
+def test_air_time_tracking(device):
+  """Verify contact sensors track time spent in/out of contact when enabled.
+
+  Tests the track_air_time feature which monitors how long each contact point
+  has been in the air (no contact) or on ground (in contact), useful for
+  gait analysis and landing detection in legged robots.
+  """
+  feet_sensor_cfg = ContactSensorCfg(
+    name="feet_contact",
+    primary=ContactMatch(
+      mode="geom",
+      pattern=("left_foot_geom", "right_foot_geom"),
+      entity="biped",
+    ),
+    secondary=None,
+    fields=("found",),
+    track_air_time=True,
+  )
+
+  scene, sim = create_scene_with_sensor(BIPED_XML, "biped", feet_sensor_cfg, device)
+
+  sensor = scene["feet_contact"]
+  biped_entity = scene["biped"]
+
+  # Start on ground.
+  root_state = torch.zeros((2, 13), device=sim.device)
+  root_state[:, 2] = 0.24  # Low enough for contact
+  root_state[:, 3] = 1.0
+  biped_entity.write_root_state_to_sim(root_state)
+
+  # Let it settle and establish ground contact.
+  for _ in range(30):
+    sim.step()
+    scene.update(dt=sim.cfg.mujoco.timestep)
+
+  data1 = sensor.data
+  # Check that we have ground contact initially.
+  assert torch.any(data1.found > 0)
+
+  # Jump up (lift biped off ground).
+  root_state[:, 2] = 1.0
+  biped_entity.write_root_state_to_sim(root_state)
+
+  # Simulate being in air.
+  for _ in range(20):
+    sim.step()
+    scene.update(dt=sim.cfg.mujoco.timestep)
+
+  data2 = sensor.data
+  # Should have no ground contact while in air.
+  assert torch.all(data2.found == 0)
+
+  # When using track_air_time, we should have timing information.
+  assert hasattr(data2, "current_air_time")
+  assert hasattr(data2, "last_air_time")
+
+  # Land back on ground.
+  root_state[:, 2] = 0.24
+  biped_entity.write_root_state_to_sim(root_state)
+
+  for _ in range(30):
+    sim.step()
+    scene.update(dt=sim.cfg.mujoco.timestep)
+
+  data3 = sensor.data
+  # Should have ground contact again.
+  assert torch.any(data3.found > 0)
+
+
+def test_air_time_exact_at_large_sim_clock(device):
+  """Air-time accumulation is independent of the sim-clock magnitude.
+
+  Regression for issue #1101: `_update_air_time_tracking` used to accumulate
+  differences of the float32 sim clock (`data.time`), so the tracked values
+  inherited the clock's quantization error (ULP ~= time * 1.2e-7). That error
+  grows without bound as `data.time` grows (it is never reset on env reset) and
+  eventually exceeds the abs_tol in compute_first_contact, silently missing
+  first-substep touchdowns.
+
+  The fix accumulates the exact float64 substep dt instead, so `data.time` is
+  never read. We advance the clock to a large value and confirm the first
+  contact substep still reads exactly dt and first-contact fires. Against the
+  old code this asserts hard: the tracked time picks up the clock magnitude.
+  """
+  cfg = ContactSensorCfg(
+    name="feet_contact",
+    primary=ContactMatch(
+      mode="geom",
+      pattern=("left_foot_geom", "right_foot_geom"),
+      entity="biped",
+    ),
+    secondary=None,
+    fields=("found",),
+    track_air_time=True,
+  )
+
+  scene, sim = create_scene_with_sensor(BIPED_XML, "biped", cfg, device)
+  sensor = scene["feet_contact"]
+  dt = sim.cfg.mujoco.timestep
+
+  ground_state = torch.zeros((2, 13), device=sim.device)
+  ground_state[:, 2] = 0.25
+  ground_state[:, 3] = 1.0
+  air_state = ground_state.clone()
+  air_state[:, 2] = 1.0
+
+  # Settle the biped onto the ground so both feet are in stable contact, then
+  # lift it clear so the feet are airborne (current_air_time > 0, found == 0).
+  scene["biped"].write_root_state_to_sim(ground_state)
+  for _ in range(20):
+    sim.step()
+    scene.update(dt=dt)
+  scene["biped"].write_root_state_to_sim(air_state)
+  for _ in range(15):
+    sim.step()
+    scene.update(dt=dt)
+  assert torch.all(sensor.data.found == 0), "expected feet airborne before landing"
+
+  # Advance the sim clock far past the regime where float32 quantization exceeds
+  # the default abs_tol. The old code differenced this clock, so the first
+  # contact substep would inherit its magnitude; the fix ignores `data.time`.
+  sim.data.time[:] = 20_000.0
+
+  # Land: a single update in contact should read exactly one dt of contact time.
+  scene["biped"].write_root_state_to_sim(ground_state)
+  sim.step()
+  scene.update(dt=dt)
+
+  data = sensor.data
+  assert data.current_contact_time is not None
+  feet_landed = data.found.view(2, len(sensor.primary_names), -1).any(dim=-1)
+  assert torch.any(feet_landed), "expected at least one foot to land"
+
+  # The first contact substep reads exactly dt, independent of the huge clock.
+  assert torch.all(torch.abs(data.current_contact_time[feet_landed] - dt) < 1e-6), (
+    data.current_contact_time
+  )
+
+  # And first-contact detection at dt=step_dt fires for the feet that landed.
+  first_contact = sensor.compute_first_contact(dt=dt)
+  assert torch.all(first_contact[feet_landed])
+
+
+##
+# Multi-sensor integration tests.
+##
+
+
+def test_multiple_sensors(device):
+  """Test multiple contact sensors in the same scene."""
+  left_sensor_cfg = ContactSensorCfg(
+    name="left_foot_contact",
+    primary=ContactMatch(mode="geom", pattern="left_foot_geom", entity="biped"),
+    secondary=None,
+    fields=("found", "force"),
+  )
+
+  right_sensor_cfg = ContactSensorCfg(
+    name="right_foot_contact",
+    primary=ContactMatch(mode="geom", pattern="right_foot_geom", entity="biped"),
+    secondary=None,
+    fields=("found", "force"),
+  )
+
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(BIPED_XML))
+
+  scene_cfg = SceneCfg(
+    num_envs=2,
+    env_spacing=3.0,
+    entities={"biped": entity_cfg},
+    sensors=(left_sensor_cfg, right_sensor_cfg),
+  )
+
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim_cfg = SimulationCfg(njmax=40)
+  sim = Simulation(num_envs=2, cfg=sim_cfg, model=model, device=device)
+  scene.initialize(sim.mj_model, sim.model, sim.data)
+
+  left_sensor = scene["left_foot_contact"]
+  right_sensor = scene["right_foot_contact"]
+
+  # Both sensors should work independently.
+  assert left_sensor.data.found.shape == (2, 1)
+  assert right_sensor.data.found.shape == (2, 1)
+
+
+##
+# Performance and edge case tests.
+##
+
+
+def test_no_contacts(device):
+  """Test sensor behavior when no contacts occur."""
+  sensor_cfg = ContactSensorCfg(
+    name="box_contact",
+    primary=ContactMatch(mode="geom", pattern="box_geom", entity="box"),
+    secondary=None,
+    fields=("found", "force"),
+  )
+
+  scene, sim = create_scene_with_sensor(FALLING_BOX_XML, "box", sensor_cfg, device)
+
+  sensor = scene["box_contact"]
+  box_entity = scene["box"]
+
+  # Place box high above ground (no contact).
+  root_state = torch.zeros((2, 13), device=sim.device)
+  root_state[:, 2] = 5.0  # Far above ground
+  root_state[:, 3] = 1.0
+  box_entity.write_root_state_to_sim(root_state)
+
+  sim.step()
+
+  data = sensor.data
+
+  # No contacts should be detected.
+  assert torch.all(data.found == 0)
+
+  # Forces should be zero.
+  assert torch.all(data.force == 0)
+
+
+def test_num_slots_greater_than_one(device):
+  """Test behavior with num_slots > 1."""
+  sensor_cfg_1 = ContactSensorCfg(
+    name="feet_contact_single",
+    primary=ContactMatch(
+      mode="geom",
+      pattern=("left_foot_geom", "right_foot_geom"),
+      entity="biped",
+    ),
+    secondary=None,
+    fields=("found", "force", "normal"),
+    num_slots=1,
+  )
+
+  sensor_cfg_3 = ContactSensorCfg(
+    name="feet_contact_triple",
+    primary=ContactMatch(
+      mode="geom",
+      pattern=("left_foot_geom", "right_foot_geom"),
+      entity="biped",
+    ),
+    secondary=None,
+    fields=("found", "force", "normal"),
+    num_slots=3,
+  )
+
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(BIPED_XML))
+
+  scene_cfg = SceneCfg(
+    num_envs=2,
+    env_spacing=3.0,
+    entities={"biped": entity_cfg},
+    sensors=(sensor_cfg_1, sensor_cfg_3),
+  )
+
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim_cfg = SimulationCfg(njmax=40)
+  sim = Simulation(num_envs=2, cfg=sim_cfg, model=model, device=device)
+  scene.initialize(sim.mj_model, sim.model, sim.data)
+
+  sensor_1 = scene["feet_contact_single"]
+  sensor_3 = scene["feet_contact_triple"]
+  biped_entity = scene["biped"]
+
+  # Place biped on ground.
+  root_state = torch.zeros((2, 13), device=sim.device)
+  root_state[:, 2] = 0.25
+  root_state[:, 3] = 1.0
+  biped_entity.write_root_state_to_sim(root_state)
+
+  step_and_settle(sim, num_steps=20)
+
+  # 2 primaries × 1 slot = 2 total slots.
+  data_1 = sensor_1.data
+  assert data_1.found is not None
+  assert data_1.force is not None
+  assert data_1.normal is not None
+  assert data_1.found.shape == (2, 2)
+  assert data_1.force.shape == (2, 2, 3)
+  assert data_1.normal.shape == (2, 2, 3)
+
+  # 2 primaries × 3 slots = 6 total slots.
+  data_3 = sensor_3.data
+  assert data_3.found is not None
+  assert data_3.force is not None
+  assert data_3.normal is not None
+  assert data_3.found.shape == (2, 6)
+  assert data_3.force.shape == (2, 6, 3)
+  assert data_3.normal.shape == (2, 6, 3)
+
+
+def test_multi_slot_air_time_and_primary_names(device):
+  """Multi-slot air-time stays per-primary, primaries are exposed by name.
+
+  Regression for issue #914: previously `num_slots > 1` with `track_air_time`
+  crashed in `_update_air_time_tracking` because air-time state was [B, P]
+  while `found` was [B, P * num_slots]. The fix reduces `found` across slots.
+  This test pins both the regression and the new `primary_names` API.
+  """
+  cfg = ContactSensorCfg(
+    name="feet_contact",
+    primary=ContactMatch(
+      mode="geom",
+      pattern=("left_foot_geom", "right_foot_geom"),
+      entity="biped",
+    ),
+    secondary=None,
+    fields=("found",),
+    num_slots=3,
+    track_air_time=True,
+  )
+
+  scene, sim = create_scene_with_sensor(BIPED_XML, "biped", cfg, device)
+  sensor = scene["feet_contact"]
+
+  # `primary_names` reflects pattern order and indexes the per-primary axis.
+  assert sensor.primary_names == ["left_foot_geom", "right_foot_geom"]
+
+  # Settle the biped on the ground so feet are in stable contact.
+  root_state = torch.zeros((2, 13), device=sim.device)
+  root_state[:, 2] = 0.25
+  root_state[:, 3] = 1.0
+  scene["biped"].write_root_state_to_sim(root_state)
+  for _ in range(20):
+    sim.step()
+    scene.update(dt=sim.cfg.mujoco.timestep)
+
+  data = sensor.data
+  assert data.found is not None
+  assert data.current_contact_time is not None
+
+  # Per-contact axis is P * num_slots; per-primary axis is P.
+  assert data.found.shape == (2, 2 * 3)
+  assert data.current_contact_time.shape == (2, len(sensor.primary_names))
+
+  # Air-time update actually ran and accumulated time for primaries in
+  # contact (not just "didn't crash"). Each foot reports a contact in some
+  # slot, so its per-primary contact time should grow above zero.
+  any_contact_per_primary = (data.found > 0).view(2, 2, 3).any(dim=-1)
+  assert torch.all(any_contact_per_primary), "expected both feet in contact"
+  assert torch.all(data.current_contact_time > 0)
+
+
+##
+# History tests.
+##
+
+
+def test_history_shape(device):
+  """Verify history tensors have correct shape [B, N, H, 3]."""
+  history_len = 5
+  sensor_cfg = ContactSensorCfg(
+    name="box_contact",
+    primary=ContactMatch(mode="geom", pattern="box_geom", entity="box"),
+    secondary=None,
+    fields=("found", "force", "torque", "dist"),
+    history_length=history_len,
+  )
+
+  scene, sim = create_scene_with_sensor(FALLING_BOX_XML, "box", sensor_cfg, device)
+
+  sensor = scene["box_contact"]
+  box_entity = scene["box"]
+
+  # Place box on ground.
+  root_state = torch.zeros((2, 13), device=sim.device)
+  root_state[:, 2] = 0.11
+  root_state[:, 3] = 1.0
+  box_entity.write_root_state_to_sim(root_state)
+
+  # Step a few times to populate history.
+  for _ in range(10):
+    sim.step()
+    scene.update(dt=sim.cfg.mujoco.timestep)
+
+  data = sensor.data
+
+  # Verify history shapes: [B, N, H, ...].
+  assert data.force_history is not None
+  assert data.torque_history is not None
+  assert data.dist_history is not None
+  assert data.force_history.shape == (2, 1, history_len, 3)
+  assert data.torque_history.shape == (2, 1, history_len, 3)
+  assert data.dist_history.shape == (2, 1, history_len)
+
+
+def test_history_ordering(device):
+  """Verify index 0 is most recent data in history buffer."""
+  history_len = 3
+  sensor_cfg = ContactSensorCfg(
+    name="box_contact",
+    primary=ContactMatch(mode="geom", pattern="box_geom", entity="box"),
+    secondary=None,
+    fields=("force",),
+    history_length=history_len,
+  )
+
+  scene, sim = create_scene_with_sensor(FALLING_BOX_XML, "box", sensor_cfg, device)
+
+  sensor = scene["box_contact"]
+  box_entity = scene["box"]
+
+  # Place box on ground to get contact.
+  root_state = torch.zeros((2, 13), device=sim.device)
+  root_state[:, 2] = 0.11
+  root_state[:, 3] = 1.0
+  box_entity.write_root_state_to_sim(root_state)
+
+  # Step and capture history at each step.
+  forces_over_time = []
+  for _ in range(5):
+    sim.step()
+    scene.update(dt=sim.cfg.mujoco.timestep)
+    # Clone to avoid tensor aliasing.
+    forces_over_time.append(sensor.data.force.clone())
+
+  data = sensor.data
+
+  # Index 0 should be most recent (last force we captured).
+  assert data.force_history is not None
+  torch.testing.assert_close(data.force_history[:, :, 0, :], forces_over_time[-1])
+
+  # Index 1 should be second most recent.
+  torch.testing.assert_close(data.force_history[:, :, 1, :], forces_over_time[-2])
+
+  # Index 2 should be third most recent.
+  torch.testing.assert_close(data.force_history[:, :, 2, :], forces_over_time[-3])
+
+
+def test_history_reset(device):
+  """Verify reset clears history for specified environments."""
+  history_len = 5
+  sensor_cfg = ContactSensorCfg(
+    name="box_contact",
+    primary=ContactMatch(mode="geom", pattern="box_geom", entity="box"),
+    secondary=None,
+    fields=("force",),
+    history_length=history_len,
+  )
+
+  scene, sim = create_scene_with_sensor(FALLING_BOX_XML, "box", sensor_cfg, device)
+
+  sensor = scene["box_contact"]
+  box_entity = scene["box"]
+
+  # Drop box from height to ensure impact forces.
+  root_state = torch.zeros((2, 13), device=sim.device)
+  root_state[:, 2] = 0.5  # Drop from 0.5m
+  root_state[:, 3] = 1.0
+  box_entity.write_root_state_to_sim(root_state)
+
+  # Let box fall and impact ground.
+  for _ in range(50):
+    sim.step()
+    scene.update(dt=sim.cfg.mujoco.timestep)
+
+  data_before = sensor.data
+  assert data_before.force_history is not None
+
+  # Manually set history to known non-zero values to test reset behavior.
+  sensor._history_state["force"][:] = 1.0
+
+  # Reset only env 0.
+  sensor.reset(torch.tensor([0], device=device))
+
+  data_after = sensor.data
+
+  # Env 0 history should be zeroed.
+  assert torch.all(data_after.force_history[0] == 0)
+
+  # Env 1 history should still have our test value.
+  assert torch.all(data_after.force_history[1] == 1.0)
+
+
+def test_history_disabled_by_default(device):
+  """Verify history is None when history_length=0 (default)."""
+  sensor_cfg = ContactSensorCfg(
+    name="box_contact",
+    primary=ContactMatch(mode="geom", pattern="box_geom", entity="box"),
+    secondary=None,
+    fields=("force",),
+    # history_length defaults to 0
+  )
+
+  scene, _ = create_scene_with_sensor(FALLING_BOX_XML, "box", sensor_cfg, device)
+
+  sensor = scene["box_contact"]
+  data = sensor.data
+
+  # History should be None when disabled.
+  assert data.force_history is None
+  assert data.torque_history is None
+  assert data.dist_history is None
+
+
+def test_history_captures_physically_correct_forces(device):
+  """Verify history captures forces that match expected physics (F = mg).
+
+  This test validates that the history buffer stores actual physics values,
+  not just that the buffer mechanics work correctly. A 1kg box at rest on
+  ground should experience a net contact force of approximately 9.81 N.
+  """
+  history_len = 10
+  sensor_cfg = ContactSensorCfg(
+    name="box_contact",
+    primary=ContactMatch(mode="geom", pattern="box_geom", entity="box"),
+    secondary=None,
+    fields=("force",),
+    history_length=history_len,
+    reduce="netforce",  # Sum all contact forces (already in global frame).
+  )
+
+  scene, sim = create_scene_with_sensor(FALLING_BOX_XML, "box", sensor_cfg, device)
+
+  sensor = scene["box_contact"]
+  box_entity = scene["box"]
+
+  # Place box just above ground and let it settle.
+  root_state = torch.zeros((2, 13), device=sim.device)
+  root_state[:, 2] = 0.11  # Just above ground (box half-height is 0.1).
+  root_state[:, 3] = 1.0  # Unit quaternion.
+  box_entity.write_root_state_to_sim(root_state)
+
+  # Let the box settle to steady state.
+  for _ in range(100):
+    sim.step()
+    scene.update(dt=sim.cfg.mujoco.timestep)
+
+  data = sensor.data
+
+  # Box mass is 1.0 kg, gravity is ~9.81 m/s².
+  # Expected normal force magnitude ≈ 9.81 N in z direction.
+  expected_force_magnitude = 9.81
+  tolerance = 1.0  # Allow 1 N tolerance for numerical settling.
+
+  # Check that the most recent force in history matches expected physics.
+  assert data.force_history is not None
+  force_z = data.force_history[
+    :, :, 0, 2
+  ]  # [B, N, H, 3] -> z-component of most recent.
+
+  # Force magnitude should match mg (sign depends on contact frame convention).
+  assert torch.allclose(
+    force_z.abs(), torch.full_like(force_z, expected_force_magnitude), atol=tolerance
+  ), f"Expected |force_z| ~{expected_force_magnitude} N, got {force_z}"
+
+  # Verify forces are consistent across recent history (steady state).
+  # In steady state, all history entries should have similar force magnitudes.
+  force_magnitudes = torch.norm(data.force_history, dim=-1)  # [B, N, H]
+  mean_force = force_magnitudes.mean(dim=2, keepdim=True)
+  max_deviation = (force_magnitudes - mean_force).abs().max()
+  assert max_deviation < 1.0, f"Forces should be steady, max deviation: {max_deviation}"
+
+
+def test_history_captures_impact_forces(device):
+  """Verify history captures transient impact forces during a drop.
+
+  This is the primary use case for the history feature: catching peak forces
+  that occur during impact but might be missed if only sampling at policy rate.
+  When a box drops and impacts the ground, the peak force should exceed the
+  steady-state force (mg) due to the impulse from deceleration.
+  """
+  history_len = 20  # Capture enough substeps to see the impact transient.
+  sensor_cfg = ContactSensorCfg(
+    name="box_contact",
+    primary=ContactMatch(mode="geom", pattern="box_geom", entity="box"),
+    secondary=None,
+    fields=("force",),
+    history_length=history_len,
+    reduce="netforce",  # Sum all contact forces.
+  )
+
+  scene, sim = create_scene_with_sensor(FALLING_BOX_XML, "box", sensor_cfg, device)
+
+  sensor = scene["box_contact"]
+  box_entity = scene["box"]
+
+  # Drop box from a height to create impact.
+  drop_height = 0.5  # 0.5m above ground (box half-height is 0.1).
+  root_state = torch.zeros((2, 13), device=sim.device)
+  root_state[:, 2] = drop_height
+  root_state[:, 3] = 1.0  # Unit quaternion.
+  box_entity.write_root_state_to_sim(root_state)
+
+  # Step until we detect contact and capture the impact.
+  max_force_seen = torch.zeros(2, device=sim.device)
+  contact_detected = False
+
+  for _ in range(200):  # Enough steps for box to fall and settle.
+    sim.step()
+    scene.update(dt=sim.cfg.mujoco.timestep)
+
+    data = sensor.data
+    if data.force_history is not None:
+      # Track the maximum force magnitude seen in history.
+      force_magnitudes = torch.norm(data.force_history, dim=-1)  # [B, N, H]
+      current_max = force_magnitudes.max(dim=-1).values.squeeze(-1)  # [B]
+      max_force_seen = torch.maximum(max_force_seen, current_max)
+
+      # Check if we have contact.
+      if torch.any(force_magnitudes > 0):
+        contact_detected = True
+
+  assert contact_detected, "Box should have made contact with ground"
+
+  # Steady state force is mg ≈ 9.81 N for 1 kg box.
+  steady_state_force = 9.81
+
+  # Peak impact force should exceed steady state due to impulse.
+  # For a drop from 0.5m, v = sqrt(2gh) ≈ 3.1 m/s at impact.
+  # The peak force depends on contact stiffness, but should be > mg.
+  assert torch.all(max_force_seen > steady_state_force), (
+    f"Peak impact force ({max_force_seen}) should exceed steady state ({steady_state_force})"
+  )
+
+  # Verify the peak force was significantly above steady state, demonstrating
+  # that the history captured the transient impact spike.
+  assert torch.all(max_force_seen > steady_state_force * 1.5), (
+    f"Peak force {max_force_seen} should be significantly above mg={steady_state_force}"
+  )
+
+
+def test_global_frame_maxforce_rotation(device):
+  """A box at rest on a plane has its contact normals all vertical."""
+  cfg = ContactSensorCfg(
+    name="box_contact",
+    primary=ContactMatch(mode="geom", pattern="box_geom", entity="box"),
+    fields=("found", "force", "normal", "tangent"),
+    reduce="maxforce",
+    global_frame=True,
+  )
+  scene, sim = create_scene_with_sensor(FALLING_BOX_XML, "box", cfg, device)
+
+  root_state = torch.zeros((2, 13), device=sim.device)
+  root_state[:, 2] = 0.11
+  root_state[:, 3] = 1.0
+  scene["box"].write_root_state_to_sim(root_state)
+  for _ in range(150):
+    sim.step()
+    scene.update(dt=sim.cfg.mujoco.timestep)
+
+  sensor_force = scene["box_contact"].data.force[:, 0, :]
+
+  # On a flat plane the contact normal is vertical, so a correctly rotated
+  # global-frame force should have its magnitude entirely on the z axis.
+  assert torch.all(sensor_force[:, 0].abs() < 0.05), (
+    f"sensor_force x-component should be ~0, got {sensor_force[:, 0].tolist()}"
+  )
+  assert torch.all(sensor_force[:, 1].abs() < 0.05), (
+    f"sensor_force y-component should be ~0, got {sensor_force[:, 1].tolist()}"
+  )
+  assert torch.all(sensor_force[:, 2].abs() > 1.0), (
+    f"sensor_force z-component should be non-trivial, got {sensor_force[:, 2].tolist()}"
+  )
diff --git a/tests/test_curriculum_manager.py b/tests/test_curriculum_manager.py
new file mode 100644
index 0000000..4aa956a
--- /dev/null
+++ b/tests/test_curriculum_manager.py
@@ -0,0 +1,41 @@
+"""Tests for CurriculumManager."""
+
+from unittest.mock import Mock
+
+import pytest
+import torch
+
+from mjlab.managers.curriculum_manager import CurriculumManager, CurriculumTermCfg
+
+
+@pytest.fixture
+def mock_env():
+  env = Mock()
+  env.num_envs = 2
+  return env
+
+
+def test_get_active_iterable_terms_handles_dict_and_scalar_state(mock_env):
+  """Dict- and scalar-shaped curriculum states both yield flat value lists.
+
+  Regression: the dict branch previously indexed `terms` (a list) by term
+  name, raising TypeError. Only observable through callers that invoke
+  get_active_iterable_terms, which no in-tree caller currently does.
+  """
+
+  def dict_state_func(env, env_ids):
+    return {"a": torch.tensor(1.5), "b": 2.0}
+
+  def scalar_state_func(env, env_ids):
+    return torch.tensor(7.0)
+
+  cfg = {
+    "dict_term": CurriculumTermCfg(func=dict_state_func, params={}),
+    "scalar_term": CurriculumTermCfg(func=scalar_state_func, params={}),
+  }
+  manager = CurriculumManager(cfg, mock_env)
+  manager.compute()
+
+  terms = dict(manager.get_active_iterable_terms(0))
+  assert terms["dict_term"] == [1.5, 2.0]
+  assert terms["scalar_term"] == [7.0]
diff --git a/tests/test_dc_actuator.py b/tests/test_dc_actuator.py
new file mode 100644
index 0000000..f24337f
--- /dev/null
+++ b/tests/test_dc_actuator.py
@@ -0,0 +1,284 @@
+"""Tests for DC motor actuator torque-speed curve."""
+
+import pytest
+import torch
+from conftest import (
+  create_entity_with_actuator,
+  get_test_device,
+  initialize_entity,
+  load_fixture_xml,
+)
+
+from mjlab.actuator import DcMotorActuatorCfg
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+@pytest.fixture(scope="module")
+def robot_xml():
+  return load_fixture_xml("floating_base_articulated")
+
+
+def test_dc_motor_stall_torque(device, robot_xml):
+  """DC motor produces full saturation_effort at zero velocity."""
+  kp = 100.0
+  kd = 10.0
+  saturation_effort = 20.0
+  velocity_limit = 30.0
+
+  entity = create_entity_with_actuator(
+    robot_xml,
+    DcMotorActuatorCfg(
+      target_names_expr=("joint.*",),
+      effort_limit=saturation_effort,  # Set to saturation to not constrain.
+      stiffness=kp,
+      damping=kd,
+      saturation_effort=saturation_effort,
+      velocity_limit=velocity_limit,
+    ),
+  )
+
+  entity, sim = initialize_entity(entity, device)
+
+  # Zero velocity, large position error to produce high PD torque.
+  joint_pos = torch.tensor([[0.0]], device=device)
+  joint_vel = torch.tensor([[0.0]], device=device)
+  entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  # Set target to produce positive torque demand >> saturation_effort.
+  entity.set_joint_position_target(torch.tensor([[2.0]], device=device))
+  entity.set_joint_velocity_target(torch.zeros(1, 1, device=device))
+  entity.set_joint_effort_target(torch.zeros(1, 1, device=device))
+  entity.write_data_to_sim()
+
+  # At zero velocity, should be clipped to saturation_effort.
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([saturation_effort], device=device))
+
+
+def test_dc_motor_zero_torque_at_max_velocity(device, robot_xml):
+  """DC motor produces zero torque at maximum velocity."""
+  kp = 100.0
+  kd = 0.0
+  saturation_effort = 20.0
+  velocity_limit = 30.0
+
+  entity = create_entity_with_actuator(
+    robot_xml,
+    DcMotorActuatorCfg(
+      target_names_expr=("joint.*",),
+      effort_limit=saturation_effort,  # Set to saturation to not constrain.
+      stiffness=kp,
+      damping=kd,
+      saturation_effort=saturation_effort,
+      velocity_limit=velocity_limit,
+    ),
+  )
+
+  entity, sim = initialize_entity(entity, device)
+
+  # At max velocity, large position error to produce high PD torque.
+  joint_pos = torch.tensor([[0.0]], device=device)
+  joint_vel = torch.tensor([[velocity_limit]], device=device)
+  entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  # Set target to produce positive torque demand >> saturation_effort.
+  entity.set_joint_position_target(torch.tensor([[2.0]], device=device))
+  entity.set_joint_velocity_target(torch.zeros(1, 1, device=device))
+  entity.set_joint_effort_target(torch.zeros(1, 1, device=device))
+  entity.write_data_to_sim()
+
+  # At max velocity, should produce zero torque.
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([0.0], device=device), atol=1e-5)
+
+
+def test_dc_motor_linear_torque_speed_curve(device, robot_xml):
+  """DC motor torque varies linearly between zero and max velocity."""
+  kp = 100.0
+  kd = 0.0
+  saturation_effort = 20.0
+  velocity_limit = 30.0
+
+  entity = create_entity_with_actuator(
+    robot_xml,
+    DcMotorActuatorCfg(
+      target_names_expr=("joint.*",),
+      effort_limit=saturation_effort,  # Set to saturation to not constrain.
+      stiffness=kp,
+      damping=kd,
+      saturation_effort=saturation_effort,
+      velocity_limit=velocity_limit,
+    ),
+  )
+
+  entity, sim = initialize_entity(entity, device)
+
+  # Test at half max velocity: should produce half saturation_effort.
+  joint_pos = torch.tensor([[0.0]], device=device)
+  joint_vel = torch.tensor([[velocity_limit / 2.0]], device=device)
+  entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  # Large position error to produce high PD torque.
+  entity.set_joint_position_target(torch.tensor([[2.0]], device=device))
+  entity.set_joint_velocity_target(torch.zeros(1, 1, device=device))
+  entity.set_joint_effort_target(torch.zeros(1, 1, device=device))
+  entity.write_data_to_sim()
+
+  # At half velocity, should produce half saturation_effort.
+  ctrl = sim.data.ctrl[0]
+  expected = saturation_effort * 0.5
+  assert torch.allclose(ctrl, torch.tensor([expected], device=device), rtol=1e-4)
+
+
+def test_dc_motor_effort_limit_constrains_output(device, robot_xml):
+  """Continuous effort_limit constrains output below saturation_effort."""
+  kp = 100.0
+  kd = 0.0
+  saturation_effort = 20.0
+  effort_limit = 5.0
+  velocity_limit = 30.0
+
+  entity = create_entity_with_actuator(
+    robot_xml,
+    DcMotorActuatorCfg(
+      target_names_expr=("joint.*",),
+      effort_limit=effort_limit,
+      stiffness=kp,
+      damping=kd,
+      saturation_effort=saturation_effort,
+      velocity_limit=velocity_limit,
+    ),
+  )
+
+  entity, sim = initialize_entity(entity, device)
+
+  # Zero velocity: would produce saturation_effort without effort_limit.
+  joint_pos = torch.tensor([[0.0]], device=device)
+  joint_vel = torch.tensor([[0.0]], device=device)
+  entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  # Large position error to produce high PD torque.
+  entity.set_joint_position_target(torch.tensor([[2.0]], device=device))
+  entity.set_joint_velocity_target(torch.zeros(1, 1, device=device))
+  entity.set_joint_effort_target(torch.zeros(1, 1, device=device))
+  entity.write_data_to_sim()
+
+  # Should be clamped to effort_limit, not saturation_effort.
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([effort_limit], device=device))
+
+
+def test_dc_motor_negative_velocity_behavior(device, robot_xml):
+  """DC motor handles negative velocities symmetrically."""
+  kp = 100.0
+  kd = 0.0
+  saturation_effort = 20.0
+  velocity_limit = 30.0
+
+  entity = create_entity_with_actuator(
+    robot_xml,
+    DcMotorActuatorCfg(
+      target_names_expr=("joint.*",),
+      effort_limit=saturation_effort,  # Set to saturation to not constrain
+      stiffness=kp,
+      damping=kd,
+      saturation_effort=saturation_effort,
+      velocity_limit=velocity_limit,
+    ),
+  )
+
+  entity, sim = initialize_entity(entity, device)
+
+  # Negative velocity, target produces negative torque demand.
+  joint_pos = torch.tensor([[0.0]], device=device)
+  joint_vel = torch.tensor([[-velocity_limit / 2.0]], device=device)
+  entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  # Set target to produce negative torque demand.
+  entity.set_joint_position_target(torch.tensor([[-2.0]], device=device))
+  entity.set_joint_velocity_target(torch.zeros(1, 1, device=device))
+  entity.set_joint_effort_target(torch.zeros(1, 1, device=device))
+  entity.write_data_to_sim()
+
+  # Should produce -half saturation_effort.
+  ctrl = sim.data.ctrl[0]
+  expected = -saturation_effort * 0.5
+  assert torch.allclose(ctrl, torch.tensor([expected], device=device), rtol=1e-4)
+
+
+def test_dc_motor_corner_velocity_transition(device, robot_xml):
+  """DC motor transitions correctly at corner velocity where curves intersect."""
+  kp = 100.0
+  kd = 0.0
+  saturation_effort = 20.0
+  effort_limit = 10.0
+  velocity_limit = 30.0
+
+  entity = create_entity_with_actuator(
+    robot_xml,
+    DcMotorActuatorCfg(
+      target_names_expr=("joint.*",),
+      effort_limit=effort_limit,
+      stiffness=kp,
+      damping=kd,
+      saturation_effort=saturation_effort,
+      velocity_limit=velocity_limit,
+    ),
+  )
+
+  entity, sim = initialize_entity(entity, device)
+
+  # Corner velocity: where torque-speed curve intersects effort_limit.
+  # vel_corner = velocity_limit * (1 - effort_limit / saturation_effort)
+  vel_corner = velocity_limit * (1.0 - effort_limit / saturation_effort)
+
+  joint_pos = torch.tensor([[0.0]], device=device)
+  joint_vel = torch.tensor([[vel_corner]], device=device)
+  entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  # Large position error to produce high PD torque.
+  entity.set_joint_position_target(torch.tensor([[2.0]], device=device))
+  entity.set_joint_velocity_target(torch.zeros(1, 1, device=device))
+  entity.set_joint_effort_target(torch.zeros(1, 1, device=device))
+  entity.write_data_to_sim()
+
+  # At corner velocity, should produce exactly effort_limit.
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([effort_limit], device=device), rtol=1e-4)
+
+
+def test_dc_motor_warns_when_effort_limit_is_inf():
+  """DcMotorActuatorCfg warns when effort_limit is inf."""
+  import warnings
+
+  # inf triggers both warnings (is inf + exceeds saturation), so catch both.
+  with warnings.catch_warnings(record=True) as w:
+    warnings.simplefilter("always")
+    DcMotorActuatorCfg(
+      target_names_expr=("joint.*",),
+      stiffness=100.0,
+      damping=10.0,
+      saturation_effort=20.0,
+      velocity_limit=30.0,
+      # effort_limit intentionally not set (defaults to inf).
+    )
+    # Should trigger the "is inf" warning.
+    assert len(w) >= 1
+    assert any("effort_limit is set to inf" in str(warning.message) for warning in w)
+
+
+def test_dc_motor_warns_when_effort_limit_exceeds_saturation():
+  """DcMotorActuatorCfg warns when effort_limit > saturation_effort."""
+  with pytest.warns(UserWarning, match="effort_limit.*exceeds saturation_effort"):
+    DcMotorActuatorCfg(
+      target_names_expr=("joint.*",),
+      stiffness=100.0,
+      damping=10.0,
+      saturation_effort=20.0,
+      velocity_limit=30.0,
+      effort_limit=25.0,  # > saturation_effort.
+    )
diff --git a/tests/test_delay_buffer.py b/tests/test_delay_buffer.py
new file mode 100644
index 0000000..3ff1009
--- /dev/null
+++ b/tests/test_delay_buffer.py
@@ -0,0 +1,327 @@
+"""Tests for DelayBuffer."""
+
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.utils.buffers import DelayBuffer
+
+
+@pytest.fixture
+def device():
+  """Test device fixture."""
+  return get_test_device()
+
+
+def make_gen(seed: int, device: str) -> torch.Generator:
+  """Create a seeded generator for reproducible tests."""
+  gen = torch.Generator(device=device)
+  gen.manual_seed(seed)
+  return gen
+
+
+##
+# Basic behavior.
+##
+
+
+def test_delay_buffer_zero_lag(device):
+  """Zero lag returns current observation."""
+  buffer = DelayBuffer(min_lag=0, max_lag=0, batch_size=2, device=device)
+
+  buffer.append(torch.tensor([[1.0], [2.0]], device=device))
+  result = buffer.compute()
+  assert torch.allclose(result, torch.tensor([[1.0], [2.0]], device=device))
+
+  buffer.append(torch.tensor([[3.0], [4.0]], device=device))
+  result = buffer.compute()
+  assert torch.allclose(result, torch.tensor([[3.0], [4.0]], device=device))
+
+
+def test_delay_buffer_constant_lag(device):
+  """Constant lag returns observation from N steps ago."""
+  buffer = DelayBuffer(min_lag=2, max_lag=2, batch_size=1, device=device)
+
+  buffer.append(torch.tensor([[1.0]], device=device))
+  result = buffer.compute()
+  assert torch.allclose(result, torch.tensor([[1.0]], device=device))
+
+  buffer.append(torch.tensor([[2.0]], device=device))
+  result = buffer.compute()
+  assert torch.allclose(result, torch.tensor([[1.0]], device=device))
+
+  buffer.append(torch.tensor([[3.0]], device=device))
+  result = buffer.compute()
+  assert torch.allclose(result, torch.tensor([[1.0]], device=device))
+
+  buffer.append(torch.tensor([[4.0]], device=device))
+  result = buffer.compute()
+  assert torch.allclose(result, torch.tensor([[2.0]], device=device))
+
+
+def test_value_matches_lag_per_env(device):
+  """Delayed values correctly match current lags."""
+  B = 3
+  buf = DelayBuffer(
+    0, 2, batch_size=B, per_env=True, device=device, generator=make_gen(1234, device)
+  )
+  for t in range(6):
+    buf.append(torch.full((B, 1), float(t), device=device))
+    y = buf.compute()
+    lags = buf.current_lags
+    for e in range(B):
+      eff = int(min(lags[e].item(), t))
+      assert y[e].item() == float(t - eff)
+
+
+##
+# Lag sampling modes.
+##
+
+
+def test_delay_buffer_per_env_lags(device):
+  """Per-env mode allows different lags per environment."""
+  buffer = DelayBuffer(min_lag=0, max_lag=3, batch_size=4, per_env=True, device=device)
+
+  for i in range(10):
+    buffer.append(torch.full((4, 1), float(i), device=device))
+    buffer.compute()
+
+  lags = buffer.current_lags
+  assert torch.all(lags >= 0)
+  assert torch.all(lags <= 3)
+
+
+def test_delay_buffer_shared_lags(device):
+  """Shared mode uses same lag across all environments."""
+  buffer = DelayBuffer(min_lag=0, max_lag=3, batch_size=4, per_env=False, device=device)
+
+  for i in range(10):
+    buffer.append(torch.full((4, 1), float(i), device=device))
+    buffer.compute()
+
+  lags = buffer.current_lags
+  assert torch.all(lags == lags[0])
+
+
+##
+# Hold probability.
+##
+
+
+def test_hold_prob_always_hold(device):
+  """hold_prob=1.0 keeps lag frozen."""
+  buf = DelayBuffer(
+    0,
+    3,
+    batch_size=1,
+    device=device,
+    update_period=1,
+    hold_prob=1.0,
+    generator=make_gen(7, device),
+  )
+  for t in range(2):
+    buf.append(torch.tensor([[float(t)]], device=device))
+    buf.compute()
+  first = buf.current_lags.item()
+  for t in range(2, 20):
+    buf.append(torch.tensor([[float(t)]], device=device))
+    buf.compute()
+    assert buf.current_lags.item() == first
+
+
+def test_hold_prob_never_hold(device):
+  """hold_prob=0.0 allows lag to change."""
+  buf = DelayBuffer(
+    0,
+    3,
+    batch_size=1,
+    device=device,
+    update_period=1,
+    hold_prob=0.0,
+    generator=make_gen(42, device),
+  )
+  for t in range(2):
+    buf.append(torch.tensor([[float(t)]], device=device))
+    buf.compute()
+  prev, changed = buf.current_lags.item(), False
+  for t in range(2, 20):
+    buf.append(torch.tensor([[float(t)]], device=device))
+    buf.compute()
+    cur = buf.current_lags.item()
+    if cur != prev:
+      changed = True
+      break
+    prev = cur
+  assert changed
+
+
+##
+# Update period.
+##
+
+
+def test_delay_buffer_update_period(device):
+  """Update period controls how often lags are resampled."""
+  buffer = DelayBuffer(
+    min_lag=0,
+    max_lag=3,
+    batch_size=1,
+    update_period=3,
+    per_env_phase=False,
+    device=device,
+  )
+
+  lag_history = []
+  for i in range(12):
+    buffer.append(torch.tensor([[float(i)]], device=device))
+    buffer.compute()
+    lag_history.append(buffer.current_lags[0].item())
+
+  assert len(lag_history) == 12
+
+
+def test_update_period_changes_only_on_schedule(device):
+  """Lags update only at scheduled intervals."""
+  buf = DelayBuffer(
+    0,
+    10,  # Wider range makes value changes more likely
+    batch_size=1,
+    update_period=3,
+    per_env_phase=False,
+    device=device,
+    generator=make_gen(123, device),
+  )
+
+  # Track when lags are updated by checking step_count timing
+  lag_values = []
+  for t in range(12):
+    buf.append(torch.tensor([[float(t)]], device=device))
+    buf.compute()
+    lag_values.append(buf.current_lags.item())
+
+  # Verify lag stays constant between update periods
+  # Update happens at step 0, 3, 6, 9
+  # So: [0-2] same, [3-5] same, [6-8] same, [9-11] same
+  assert lag_values[0] == lag_values[1] == lag_values[2]
+  assert lag_values[3] == lag_values[4] == lag_values[5]
+  assert lag_values[6] == lag_values[7] == lag_values[8]
+  assert lag_values[9] == lag_values[10] == lag_values[11]
+
+
+##
+# Reset behavior.
+##
+
+
+def test_delay_buffer_reset_all(device):
+  """Reset clears all environments."""
+  buffer = DelayBuffer(min_lag=1, max_lag=2, batch_size=2, device=device)
+
+  for i in range(5):
+    buffer.append(torch.full((2, 1), float(i), device=device))
+    buffer.compute()
+
+  buffer.reset()
+
+  assert torch.all(buffer.current_lags == 0)
+  assert torch.all(buffer._step_count == 0)
+
+
+def test_delay_buffer_reset_partial(device):
+  """Reset with batch_ids only resets specified environments."""
+  buffer = DelayBuffer(min_lag=0, max_lag=3, batch_size=4, device=device)
+
+  for _ in range(5):
+    buffer.append(torch.arange(4, device=device).unsqueeze(1).float())
+    buffer.compute()
+
+  lags_before = buffer.current_lags.clone()
+
+  buffer.reset(batch_ids=torch.tensor([0, 2], device=device))
+
+  lags_after = buffer.current_lags
+
+  assert lags_after[0] == 0
+  assert lags_after[2] == 0
+  assert lags_after[1] == lags_before[1]
+  assert lags_after[3] == lags_before[3]
+
+
+def test_partial_reset_then_backfill(device):
+  """Partial reset returns zeros until next append backfills."""
+  B = 3
+  buf = DelayBuffer(1, 2, batch_size=B, device=device, generator=make_gen(9, device))
+  for t in range(3):
+    x = torch.arange(1, B + 1, device=device).float().unsqueeze(1) * 10 + t
+    buf.append(x)
+    buf.compute()
+  buf.reset(batch_ids=torch.tensor([1], device=device))
+  y = buf.compute()
+  assert torch.allclose(y[1], torch.zeros_like(y[1]))
+  x_new = torch.tensor([[111.0], [999.0], [333.0]], device=device)
+  buf.append(x_new)
+  y2 = buf.compute()
+  assert torch.allclose(y2[1], torch.tensor([[999.0]], device=device))
+
+
+##
+# Error handling.
+##
+
+
+def test_delay_buffer_not_initialized(device):
+  """Compute before append raises error."""
+  buffer = DelayBuffer(min_lag=0, max_lag=3, batch_size=1, device=device)
+
+  with pytest.raises(RuntimeError, match="Buffer not initialized"):
+    buffer.compute()
+
+
+def test_append_wrong_batch_raises(device):
+  """Appending wrong batch size raises error."""
+  buf = DelayBuffer(0, 1, batch_size=2, device=device)
+  with pytest.raises(ValueError):
+    buf.append(torch.zeros(3, 1, device=device))
+
+
+def test_delay_buffer_validation(device):
+  """Input validation catches invalid parameters."""
+  with pytest.raises(ValueError, match="min_lag must be >= 0"):
+    DelayBuffer(min_lag=-1, max_lag=3, batch_size=1, device=device)
+
+  with pytest.raises(ValueError, match="max_lag.*must be >= min_lag"):
+    DelayBuffer(min_lag=5, max_lag=3, batch_size=1, device=device)
+
+  with pytest.raises(ValueError, match="hold_prob must be in"):
+    DelayBuffer(min_lag=0, max_lag=3, batch_size=1, hold_prob=1.5, device=device)
+
+  with pytest.raises(ValueError, match="update_period must be >= 0"):
+    DelayBuffer(min_lag=0, max_lag=3, batch_size=1, update_period=-1, device=device)
+
+
+def test_backfill_and_peek_leave_others_untouched(device):
+  """backfill serves the reset row's new frame; peek advances no schedules."""
+  B = 3
+  buf = DelayBuffer(1, 2, batch_size=B, device=device, generator=make_gen(9, device))
+  for t in range(4):
+    x = torch.arange(1, B + 1, device=device).float().unsqueeze(1) * 10 + t
+    buf.append(x)
+    buf.compute()
+
+  out_before = buf.peek()
+  lags_before = buf.current_lags.clone()
+  steps_before = buf._step_count.clone()
+
+  reset_ids = torch.tensor([1], device=device)
+  buf.reset(batch_ids=reset_ids)
+  buf.backfill(torch.tensor([[-1.0], [999.0], [-1.0]], device=device), reset_ids)
+  out = buf.peek()
+
+  # Reset row serves its backfilled frame (lag zeroed, one valid frame).
+  assert torch.allclose(out[1], torch.tensor([999.0], device=device))
+  # Other rows: same delayed frame, lags and schedule untouched.
+  keep = torch.tensor([0, 2], device=device)
+  assert torch.allclose(out[keep], out_before[keep])
+  assert torch.equal(buf.current_lags[keep], lags_before[keep])
+  assert torch.equal(buf._step_count[keep], steps_before[keep])
diff --git a/tests/test_delayed_actuator.py b/tests/test_delayed_actuator.py
new file mode 100644
index 0000000..6d90bf2
--- /dev/null
+++ b/tests/test_delayed_actuator.py
@@ -0,0 +1,363 @@
+"""Tests for delayed actuators."""
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device, load_fixture_xml
+
+from mjlab.actuator import (
+  BuiltinPositionActuatorCfg,
+  IdealPdActuatorCfg,
+)
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+ROBOT_XML = load_fixture_xml("floating_base_articulated")
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+def create_entity_with_delayed_builtin(delay_min_lag=0, delay_max_lag=3):
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinPositionActuatorCfg(
+          target_names_expr=("joint.*",),
+          effort_limit=100.0,
+          stiffness=80.0,
+          damping=10.0,
+          delay_min_lag=delay_min_lag,
+          delay_max_lag=delay_max_lag,
+        ),
+      )
+    ),
+  )
+  return Entity(cfg)
+
+
+def create_entity_with_delayed_ideal(delay_min_lag=0, delay_max_lag=3):
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        IdealPdActuatorCfg(
+          target_names_expr=("joint.*",),
+          effort_limit=100.0,
+          stiffness=80.0,
+          damping=10.0,
+          delay_min_lag=delay_min_lag,
+          delay_max_lag=delay_max_lag,
+        ),
+      )
+    ),
+  )
+  return Entity(cfg)
+
+
+def initialize_entity(entity, device, num_envs=1):
+  model = entity.compile()
+  sim_cfg = SimulationCfg()
+  sim = Simulation(num_envs=num_envs, cfg=sim_cfg, model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+  return entity, sim
+
+
+def test_delayed_builtin_applies_constant_delay(device):
+  """Test that delayed builtin actuator delays position targets."""
+  entity = create_entity_with_delayed_builtin(delay_min_lag=2, delay_max_lag=2)
+  entity, sim = initialize_entity(entity, device)
+
+  # Set position targets for 3 steps.
+  targets = [
+    torch.tensor([[0.1, 0.2]], device=device),
+    torch.tensor([[0.3, 0.4]], device=device),
+    torch.tensor([[0.5, 0.6]], device=device),
+  ]
+
+  joint_vel = torch.zeros(1, 2, device=device)
+
+  for target in targets:
+    entity.set_joint_position_target(target)
+    entity.set_joint_velocity_target(joint_vel)
+    entity.set_joint_effort_target(torch.zeros(1, 2, device=device))
+    entity.write_data_to_sim()
+
+  # After 3 steps with lag=2, the output should be the target from step 0.
+  ctrl = sim.data.ctrl[0]
+  # With constant lag=2, after 3 appends, we expect target from step 0.
+  assert torch.allclose(ctrl, targets[0][0], atol=1e-5)
+
+
+def test_delayed_ideal_applies_delay(device):
+  """Test that delayed ideal actuator delays position targets."""
+  entity = create_entity_with_delayed_ideal(delay_min_lag=2, delay_max_lag=2)
+  entity, sim = initialize_entity(entity, device)
+
+  joint_pos = torch.zeros(1, 2, device=device)
+  joint_vel = torch.zeros(1, 2, device=device)
+  entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  # Set position targets for 3 steps.
+  targets = [
+    torch.tensor([[0.1, 0.2]], device=device),
+    torch.tensor([[0.3, 0.4]], device=device),
+    torch.tensor([[0.5, 0.6]], device=device),
+  ]
+
+  for target in targets:
+    entity.set_joint_position_target(target)
+    entity.set_joint_velocity_target(joint_vel)
+    entity.set_joint_effort_target(torch.zeros(1, 2, device=device))
+    entity.write_data_to_sim()
+    sim.forward()  # Compute actuator forces
+
+  # The computed torque should use the delayed target from step 0.
+  joint_v_adr = entity.indexing.joint_v_adr
+  qfrc = sim.data.qfrc_actuator[0, joint_v_adr]
+
+  # Expected torque: kp * (delayed_target - joint_pos) + kd * (0 - joint_vel) + 0
+  # = 80.0 * targets[0] + 0 = 80.0 * [0.1, 0.2]
+  expected_torque = 80.0 * targets[0][0]
+  assert torch.allclose(qfrc, expected_torque, atol=1e-4)
+
+
+def test_delayed_ideal_delays_velocity(device):
+  """Velocity targets share the same delay as position targets.
+
+  Regression test: the velocity reference used to bypass the delay buffer, so
+  the damping term consumed the latest target instead of the delayed one.
+  """
+  entity = create_entity_with_delayed_ideal(delay_min_lag=2, delay_max_lag=2)
+  entity, sim = initialize_entity(entity, device)
+
+  joint_pos = torch.zeros(1, 2, device=device)
+  joint_vel = torch.zeros(1, 2, device=device)
+  entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  # Only the velocity target varies; position and effort stay zero.
+  vel_targets = [
+    torch.tensor([[0.1, 0.2]], device=device),
+    torch.tensor([[0.3, 0.4]], device=device),
+    torch.tensor([[0.5, 0.6]], device=device),
+  ]
+
+  for vel_target in vel_targets:
+    entity.set_joint_position_target(joint_pos)
+    entity.set_joint_velocity_target(vel_target)
+    entity.set_joint_effort_target(torch.zeros(1, 2, device=device))
+    entity.write_data_to_sim()
+    sim.forward()
+
+  joint_v_adr = entity.indexing.joint_v_adr
+  qfrc = sim.data.qfrc_actuator[0, joint_v_adr]
+
+  # With lag=2, the damping term uses the velocity target from step 0:
+  # kd * (delayed_vel_target - 0) = 10.0 * [0.1, 0.2].
+  expected_torque = 10.0 * vel_targets[0][0]
+  assert torch.allclose(qfrc, expected_torque, atol=1e-4)
+
+
+def test_delayed_ideal_delays_effort(device):
+  """Feedforward effort targets share the same delay as position targets."""
+  entity = create_entity_with_delayed_ideal(delay_min_lag=2, delay_max_lag=2)
+  entity, sim = initialize_entity(entity, device)
+
+  joint_pos = torch.zeros(1, 2, device=device)
+  joint_vel = torch.zeros(1, 2, device=device)
+  entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  effort_targets = [
+    torch.tensor([[1.0, 2.0]], device=device),
+    torch.tensor([[3.0, 4.0]], device=device),
+    torch.tensor([[5.0, 6.0]], device=device),
+  ]
+
+  for effort_target in effort_targets:
+    entity.set_joint_position_target(joint_pos)
+    entity.set_joint_velocity_target(joint_vel)
+    entity.set_joint_effort_target(effort_target)
+    entity.write_data_to_sim()
+    sim.forward()
+
+  joint_v_adr = entity.indexing.joint_v_adr
+  qfrc = sim.data.qfrc_actuator[0, joint_v_adr]
+
+  # With lag=2, the feedforward term uses the effort target from step 0.
+  expected_torque = effort_targets[0][0]
+  assert torch.allclose(qfrc, expected_torque, atol=1e-4)
+
+
+def test_delayed_actuator_reset(device):
+  """Test that reset clears the delay buffer."""
+  entity = create_entity_with_delayed_builtin(delay_min_lag=1, delay_max_lag=3)
+  entity, _ = initialize_entity(entity, device, num_envs=2)
+
+  # Set some targets to fill the buffer.
+  entity.set_joint_position_target(torch.ones(2, 2, device=device) * 0.5)
+  entity.set_joint_velocity_target(torch.zeros(2, 2, device=device))
+  entity.set_joint_effort_target(torch.zeros(2, 2, device=device))
+  entity.write_data_to_sim()
+
+  # Reset env 0.
+  entity.reset(torch.tensor([0], device=device))
+
+  # Check that delay buffer was reset for env 0.
+  actuator = entity.actuators[0]
+  assert actuator.has_delay
+  assert actuator._delay_buffer is not None
+  assert actuator._delay_buffer.current_lags[0] == 0
+
+
+def test_delayed_actuator_set_lags(device):
+  """Test that set_lags sets lag values on all delay buffers."""
+  entity = create_entity_with_delayed_builtin(delay_min_lag=0, delay_max_lag=5)
+  entity, _ = initialize_entity(entity, device, num_envs=4)
+
+  actuator = entity.actuators[0]
+  assert actuator.has_delay
+
+  # Set lags for all environments.
+  lags = torch.tensor([1, 2, 3, 4], device=device)
+  actuator.set_lags(lags)
+
+  # Check that lags were set.
+  buffer = actuator._delay_buffer
+  assert buffer is not None
+  assert torch.equal(buffer.current_lags, lags)
+
+
+def test_delayed_actuator_set_lags_subset(device):
+  """Test that set_lags can set lag values for a subset of environments."""
+  entity = create_entity_with_delayed_builtin(delay_min_lag=0, delay_max_lag=5)
+  entity, _ = initialize_entity(entity, device, num_envs=4)
+
+  actuator = entity.actuators[0]
+  assert actuator.has_delay
+
+  # Set lags for envs 1 and 3 only.
+  env_ids = torch.tensor([1, 3], device=device)
+  lags = torch.tensor([4, 5], device=device)
+  actuator.set_lags(lags, env_ids)
+
+  # Check that only specified envs were updated.
+  buffer = actuator._delay_buffer
+  assert buffer is not None
+  assert buffer.current_lags[0] == 0  # Unchanged (initial value)
+  assert buffer.current_lags[1] == 4
+  assert buffer.current_lags[2] == 0  # Unchanged
+  assert buffer.current_lags[3] == 5
+
+
+def test_delayed_actuator_set_lags_clamps_to_range(device):
+  """Test that set_lags clamps values to the configured lag range."""
+  entity = create_entity_with_delayed_builtin(delay_min_lag=1, delay_max_lag=3)
+  entity, _ = initialize_entity(entity, device, num_envs=2)
+
+  actuator = entity.actuators[0]
+  assert actuator.has_delay
+
+  # Try to set lags outside the valid range.
+  lags = torch.tensor([0, 10], device=device)  # 0 < min_lag, 10 > max_lag
+  actuator.set_lags(lags)
+
+  # Lags should be clamped to [1, 3].
+  buffer = actuator._delay_buffer
+  assert buffer is not None
+  assert buffer.current_lags[0] == 1  # Clamped from 0
+  assert buffer.current_lags[1] == 3  # Clamped from 10
+
+
+def test_delayed_actuator_set_lags_affects_delay(device):
+  """Test that setting lags actually changes the delay behavior."""
+  # Use hold_prob=1.0 to prevent automatic lag resampling.
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinPositionActuatorCfg(
+          target_names_expr=("joint.*",),
+          effort_limit=100.0,
+          stiffness=80.0,
+          damping=10.0,
+          delay_min_lag=0,
+          delay_max_lag=5,
+          delay_hold_prob=1.0,  # Prevent automatic resampling
+        ),
+      )
+    ),
+  )
+  entity = Entity(cfg)
+  entity, sim = initialize_entity(entity, device, num_envs=1)
+
+  actuator = entity.actuators[0]
+  assert actuator.has_delay
+
+  # Set lag to 1.
+  actuator.set_lags(torch.tensor([1], device=device))
+
+  # Fill the buffer with known targets.
+  targets = [
+    torch.tensor([[0.1, 0.2]], device=device),
+    torch.tensor([[0.3, 0.4]], device=device),
+    torch.tensor([[0.5, 0.6]], device=device),
+  ]
+
+  for target in targets:
+    entity.set_joint_position_target(target)
+    entity.set_joint_velocity_target(torch.zeros(1, 2, device=device))
+    entity.set_joint_effort_target(torch.zeros(1, 2, device=device))
+    entity.write_data_to_sim()
+
+  # With lag=1, after 3 steps, ctrl should use target from step 1 (index 1).
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, targets[1][0], atol=1e-5)
+
+
+def test_delayed_actuator_set_lags_overwritten_without_hold_prob(device):
+  """Test that set_lags gets overwritten when delay_hold_prob < 1.0."""
+  # Use min_lag=max_lag=2 so resampling always produces 2.
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinPositionActuatorCfg(
+          target_names_expr=("joint.*",),
+          effort_limit=100.0,
+          stiffness=80.0,
+          damping=10.0,
+          delay_min_lag=2,
+          delay_max_lag=2,
+          delay_hold_prob=0.0,  # Always resample
+        ),
+      )
+    ),
+  )
+  entity = Entity(cfg)
+  entity, sim = initialize_entity(entity, device, num_envs=1)
+
+  actuator = entity.actuators[0]
+  assert actuator.has_delay
+  buffer = actuator._delay_buffer
+  assert buffer is not None
+
+  # Set lag to 2 (the only valid value, so set_lags won't clamp it).
+  actuator.set_lags(torch.tensor([2], device=device))
+  assert buffer.current_lags[0] == 2
+
+  # Now manually set _current_lags to 0 to simulate "we want 0".
+  # This bypasses clamping to test the resampling behavior.
+  buffer._current_lags[0] = 0
+  assert buffer.current_lags[0] == 0
+
+  # After compute, with hold_prob=0.0, it resamples to [min_lag, max_lag] = 2.
+  entity.set_joint_position_target(torch.zeros(1, 2, device=device))
+  entity.set_joint_velocity_target(torch.zeros(1, 2, device=device))
+  entity.set_joint_effort_target(torch.zeros(1, 2, device=device))
+  entity.write_data_to_sim()
+
+  # Lag should have been resampled back to 2.
+  assert buffer.current_lags[0] == 2
diff --git a/tests/test_differential_ik_action.py b/tests/test_differential_ik_action.py
new file mode 100644
index 0000000..6f19d49
--- /dev/null
+++ b/tests/test_differential_ik_action.py
@@ -0,0 +1,423 @@
+"""Tests for differential IK action space."""
+
+from unittest.mock import Mock
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.actuator.actuator import TransmissionType
+from mjlab.actuator.builtin_actuator import BuiltinPositionActuatorCfg
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.envs import ManagerBasedRlEnv
+from mjlab.envs.mdp.actions import DifferentialIKAction, DifferentialIKActionCfg
+from mjlab.sim.sim import MujocoCfg, Simulation, SimulationCfg
+from mjlab.utils.lab_api.math import axis_angle_from_quat, quat_mul
+
+ARM_XML = """\
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 0.5">
+      <geom name="base_geom" type="cylinder" size="0.05 0.02" mass="1.0"
+            contype="0" conaffinity="0"/>
+      <body name="link1" pos="0 0 0.02">
+        <joint name="joint1" type="hinge" axis="0 1 0" range="-3.14 3.14"/>
+        <geom name="link1_geom" type="capsule" fromto="0 0 0 0 0 0.3"
+              size="0.02" mass="0.5" contype="0" conaffinity="0"/>
+        <body name="link2" pos="0 0 0.3">
+          <joint name="joint2" type="hinge" axis="0 1 0" range="-3.14 3.14"/>
+          <geom name="link2_geom" type="capsule" fromto="0 0 0 0 0 0.3"
+                size="0.02" mass="0.5" contype="0" conaffinity="0"/>
+          <body name="ee" pos="0 0 0.3">
+            <joint name="joint3" type="hinge" axis="0 1 0"
+                   range="-3.14 3.14"/>
+            <geom name="ee_geom" type="sphere" size="0.03" mass="0.1"
+                  contype="0" conaffinity="0"/>
+            <site name="ee_site" pos="0 0 0.05"/>
+          </body>
+        </body>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+TIGHT_ARM_XML = """\
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 0.5">
+      <geom name="base_geom" type="cylinder" size="0.05 0.02" mass="1.0"
+            contype="0" conaffinity="0"/>
+      <body name="link1" pos="0 0 0.02">
+        <joint name="joint1" type="hinge" axis="0 1 0" range="-0.5 0.5"/>
+        <geom name="link1_geom" type="capsule" fromto="0 0 0 0 0 0.3"
+              size="0.02" mass="0.5" contype="0" conaffinity="0"/>
+        <body name="link2" pos="0 0 0.3">
+          <joint name="joint2" type="hinge" axis="0 1 0" range="-0.5 0.5"/>
+          <geom name="link2_geom" type="capsule" fromto="0 0 0 0 0 0.3"
+                size="0.02" mass="0.5" contype="0" conaffinity="0"/>
+          <body name="ee" pos="0 0 0.3">
+            <joint name="joint3" type="hinge" axis="0 1 0"
+                   range="-0.5 0.5"/>
+            <geom name="ee_geom" type="sphere" size="0.03" mass="0.1"
+                  contype="0" conaffinity="0"/>
+          </body>
+        </body>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+NUM_ENVS = 4
+
+
+@pytest.fixture
+def device():
+  return get_test_device()
+
+
+def _make_entity(device, xml=ARM_XML):
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(xml),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinPositionActuatorCfg(
+          target_names_expr=("joint.*",),
+          transmission_type=TransmissionType.JOINT,
+          stiffness=1.0,
+          damping=1.0,
+          effort_limit=1.0,
+        ),
+      )
+    ),
+  )
+  entity = Entity(cfg)
+  model = entity.compile()
+  sim_cfg = SimulationCfg(mujoco=MujocoCfg(gravity=(0, 0, 0)))
+  sim = Simulation(num_envs=NUM_ENVS, cfg=sim_cfg, model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+  return entity, sim
+
+
+def _make_env(entity, sim, device):
+  env = Mock(spec=ManagerBasedRlEnv)
+  env.num_envs = NUM_ENVS
+  env.device = device
+  env.scene = {"robot": entity}
+  env.sim = sim
+  return env
+
+
+@pytest.mark.parametrize(
+  "orientation_weight,relative,expected_dim",
+  [
+    (0.0, True, 3),
+    (0.0, False, 3),
+    (1.0, True, 6),
+    (1.0, False, 7),
+  ],
+)
+def test_action_dim(device, orientation_weight, relative, expected_dim):
+  entity, sim = _make_entity(device)
+  env = _make_env(entity, sim, device)
+  cfg = DifferentialIKActionCfg(
+    entity_name="robot",
+    actuator_names=("joint.*",),
+    frame_name="ee",
+    frame_type="body",
+    orientation_weight=orientation_weight,
+    use_relative_mode=relative,
+  )
+  action = cfg.build(env)
+  assert action.action_dim == expected_dim
+
+
+@pytest.mark.parametrize(
+  "frame_type,frame_name",
+  [
+    ("body", "ee"),
+    ("site", "ee_site"),
+    ("geom", "ee_geom"),
+  ],
+)
+def test_frame_types(device, frame_type, frame_name):
+  entity, sim = _make_entity(device)
+  env = _make_env(entity, sim, device)
+  cfg = DifferentialIKActionCfg(
+    entity_name="robot",
+    actuator_names=("joint.*",),
+    frame_name=frame_name,
+    frame_type=frame_type,
+    orientation_weight=0.0,
+  )
+  action: DifferentialIKAction = cfg.build(env)
+  assert action.action_dim == 3
+
+  pos, quat = action._get_frame_pose()
+  assert pos.shape == (NUM_ENVS, 3)
+  assert quat.shape == (NUM_ENVS, 4)
+
+
+def test_ik_convergence_position(device):
+  """Verify IK converges kinematically by writing q+dq directly to qpos."""
+  entity, sim = _make_entity(device)
+  env = _make_env(entity, sim, device)
+  cfg = DifferentialIKActionCfg(
+    entity_name="robot",
+    actuator_names=("joint.*",),
+    frame_name="ee",
+    frame_type="body",
+    orientation_weight=0.0,
+    use_relative_mode=False,
+    damping=0.05,
+  )
+  action: DifferentialIKAction = cfg.build(env)
+
+  initial_pos, _ = action._get_frame_pose()
+  target = initial_pos.clone()
+  target[:, 0] += 0.05
+
+  action.process_actions(target)
+  for _ in range(10):
+    dq = action.compute_dq()
+    q = entity.data.joint_pos[:, action._joint_ids] + dq
+    entity.write_joint_position_to_sim(q, joint_ids=action._joint_ids)
+    sim.forward()
+
+  final_pos, _ = action._get_frame_pose()
+  error = (final_pos - target).norm(dim=-1)
+  assert (error < 0.003).all(), f"Position error too large: {error}"
+
+
+def test_reset_clears_buffers(device):
+  entity, sim = _make_entity(device)
+  env = _make_env(entity, sim, device)
+  cfg = DifferentialIKActionCfg(
+    entity_name="robot",
+    actuator_names=("joint.*",),
+    frame_name="ee",
+    frame_type="body",
+  )
+  action: DifferentialIKAction = cfg.build(env)
+
+  actions = torch.randn(NUM_ENVS, 6, device=device)
+  action.process_actions(actions)
+
+  reset_ids = torch.tensor([0, 2], device=device)
+  action.reset(env_ids=reset_ids)
+
+  assert torch.all(action.raw_action[[0, 2]] == 0.0)
+  assert not torch.all(action.raw_action[[1, 3]] == 0.0)
+
+
+def test_joint_limits_respected(device):
+  """IK with joint_limit_weight keeps joints within bounds."""
+  entity, sim = _make_entity(device, xml=TIGHT_ARM_XML)
+  env = _make_env(entity, sim, device)
+
+  action_no_lim: DifferentialIKAction = DifferentialIKActionCfg(
+    entity_name="robot",
+    actuator_names=("joint.*",),
+    frame_name="ee",
+    frame_type="body",
+    orientation_weight=0.0,
+    use_relative_mode=False,
+    damping=0.05,
+  ).build(env)
+  action_lim: DifferentialIKAction = DifferentialIKActionCfg(
+    entity_name="robot",
+    actuator_names=("joint.*",),
+    frame_name="ee",
+    frame_type="body",
+    orientation_weight=0.0,
+    use_relative_mode=False,
+    damping=0.05,
+    joint_limit_weight=10.0,
+  ).build(env)
+
+  initial_pos, _ = action_no_lim._get_frame_pose()
+  target = initial_pos.clone()
+  target[:, 0] += 0.15
+
+  limits = entity.data.soft_joint_pos_limits[:, action_lim._joint_ids]
+  for action in (action_no_lim, action_lim):
+    entity.write_joint_position_to_sim(
+      torch.zeros(NUM_ENVS, 3, device=device),
+      joint_ids=action._joint_ids,
+    )
+    sim.forward()
+    action.process_actions(target)
+    for _ in range(10):
+      dq = action.compute_dq()
+      q = entity.data.joint_pos[:, action._joint_ids] + dq
+      entity.write_joint_position_to_sim(q, joint_ids=action._joint_ids)
+      sim.forward()
+
+  q_lim = entity.data.joint_pos[:, action_lim._joint_ids]
+  upper_viol = (q_lim - limits[..., 1]).clamp(min=0).sum()
+  lower_viol = (limits[..., 0] - q_lim).clamp(min=0).sum()
+  total_violation = upper_viol + lower_viol
+  assert total_violation < 0.01, f"Joint limit violation too large: {total_violation}"
+
+
+def _quat_conjugate(q: torch.Tensor) -> torch.Tensor:
+  return torch.cat([q[..., :1], -q[..., 1:]], dim=-1)
+
+
+def _central_fd_position(action, entity, sim, q0, eps):
+  """Central finite-difference position Jacobian."""
+  nj = action._num_joints
+  jacp_fd = torch.zeros(q0.shape[0], 3, nj, device=q0.device)
+  for i in range(nj):
+    q_plus = q0.clone()
+    q_plus[:, i] += eps
+    entity.write_joint_position_to_sim(q_plus, joint_ids=action._joint_ids)
+    sim.forward()
+    pos_plus = action._get_frame_pose()[0].clone()
+
+    q_minus = q0.clone()
+    q_minus[:, i] -= eps
+    entity.write_joint_position_to_sim(q_minus, joint_ids=action._joint_ids)
+    sim.forward()
+    pos_minus = action._get_frame_pose()[0].clone()
+
+    jacp_fd[:, :, i] = (pos_plus - pos_minus) / (2 * eps)
+  return jacp_fd
+
+
+def _central_fd_orientation(action, entity, sim, q0, quat0, eps):
+  """Central finite-difference rotation Jacobian via axis-angle."""
+  nj = action._num_joints
+  jacr_fd = torch.zeros(q0.shape[0], 3, nj, device=q0.device)
+  for i in range(nj):
+    q_plus = q0.clone()
+    q_plus[:, i] += eps
+    entity.write_joint_position_to_sim(q_plus, joint_ids=action._joint_ids)
+    sim.forward()
+    _, quat_plus = action._get_frame_pose()
+    q_diff_plus = quat_mul(quat_plus, _quat_conjugate(quat0))
+    aa_plus = axis_angle_from_quat(q_diff_plus)
+
+    q_minus = q0.clone()
+    q_minus[:, i] -= eps
+    entity.write_joint_position_to_sim(q_minus, joint_ids=action._joint_ids)
+    sim.forward()
+    _, quat_minus = action._get_frame_pose()
+    q_diff_minus = quat_mul(quat_minus, _quat_conjugate(quat0))
+    aa_minus = axis_angle_from_quat(q_diff_minus)
+
+    jacr_fd[:, :, i] = (aa_plus - aa_minus) / (2 * eps)
+  return jacr_fd
+
+
+# Float32 central FD: truncation O(eps^2) ~ 1e-6, round-off O(u/eps) ~ 1e-4.
+_FD_EPS = 1e-3
+_FD_ATOL = 1e-3
+
+
+def test_jacobian_finite_difference_position(device):
+  """Verify position Jacobian against central finite differences."""
+  entity, sim = _make_entity(device)
+  env = _make_env(entity, sim, device)
+  cfg = DifferentialIKActionCfg(
+    entity_name="robot",
+    actuator_names=("joint.*",),
+    frame_name="ee",
+    frame_type="body",
+    orientation_weight=0.0,
+    use_relative_mode=False,
+    damping=0.05,
+  )
+  action: DifferentialIKAction = cfg.build(env)
+
+  q0 = 0.3 * torch.tensor([[0.5, -0.3, 0.8]] * NUM_ENVS, device=device)
+  entity.write_joint_position_to_sim(q0, joint_ids=action._joint_ids)
+  sim.forward()
+
+  pos0 = action._get_frame_pose()[0].clone()
+  action._point_torch[:] = pos0
+  action._compute_jacobian()
+  jacp_analytic = action._jacp_torch[:, :, action._joint_dof_ids].clone()
+
+  jacp_fd = _central_fd_position(action, entity, sim, q0, _FD_EPS)
+
+  assert torch.allclose(jacp_analytic, jacp_fd, atol=_FD_ATOL), (
+    f"Position Jacobian mismatch.\n"
+    f"Max error: {(jacp_analytic - jacp_fd).abs().max():.2e}"
+  )
+
+
+def test_jacobian_finite_difference_orientation(device):
+  """Verify rotation Jacobian against central finite differences."""
+  entity, sim = _make_entity(device)
+  env = _make_env(entity, sim, device)
+  cfg = DifferentialIKActionCfg(
+    entity_name="robot",
+    actuator_names=("joint.*",),
+    frame_name="ee",
+    frame_type="body",
+    use_relative_mode=False,
+    damping=0.05,
+  )
+  action: DifferentialIKAction = cfg.build(env)
+
+  q0 = 0.3 * torch.tensor([[0.5, -0.3, 0.8]] * NUM_ENVS, device=device)
+  entity.write_joint_position_to_sim(q0, joint_ids=action._joint_ids)
+  sim.forward()
+
+  _, quat0 = action._get_frame_pose()
+  quat0 = quat0.clone()
+
+  pos0 = action._get_frame_pose()[0].clone()
+  action._point_torch[:] = pos0
+  action._compute_jacobian()
+  jacr_analytic = action._jacr_torch[:, :, action._joint_dof_ids].clone()
+
+  jacr_fd = _central_fd_orientation(action, entity, sim, q0, quat0, _FD_EPS)
+
+  assert torch.allclose(jacr_analytic, jacr_fd, atol=_FD_ATOL), (
+    f"Rotation Jacobian mismatch.\n"
+    f"Max error: {(jacr_analytic - jacr_fd).abs().max():.2e}"
+  )
+
+
+def test_posture_regularization(device):
+  """Posture weight biases joints toward target when task error is zero."""
+  entity, sim = _make_entity(device)
+  env = _make_env(entity, sim, device)
+
+  cfg = DifferentialIKActionCfg(
+    entity_name="robot",
+    actuator_names=("joint.*",),
+    frame_name="ee",
+    frame_type="body",
+    orientation_weight=0.0,
+    use_relative_mode=False,
+    damping=0.05,
+    posture_weight=0.1,
+    posture_target={".*": 0.0},
+  )
+  action: DifferentialIKAction = cfg.build(env)
+
+  q0 = torch.tensor([[0.3, -0.2, 0.5]] * NUM_ENVS, device=device)
+  entity.write_joint_position_to_sim(q0, joint_ids=action._joint_ids)
+  sim.forward()
+
+  # Target = current frame position, so only posture term drives motion.
+  frame_pos, _ = action._get_frame_pose()
+  action.process_actions(frame_pos.clone())
+
+  for _ in range(10):
+    dq = action.compute_dq()
+    q = entity.data.joint_pos[:, action._joint_ids] + dq
+    entity.write_joint_position_to_sim(q, joint_ids=action._joint_ids)
+    sim.forward()
+
+  q_final = entity.data.joint_pos[:, action._joint_ids]
+  assert q_final.abs().mean() < q0.abs().mean(), (
+    f"Posture regularization did not pull toward target.\n"
+    f"Initial mean |q|: {q0.abs().mean():.4f}, "
+    f"Final mean |q|: {q_final.abs().mean():.4f}"
+  )
diff --git a/tests/test_domain_randomization.py b/tests/test_domain_randomization.py
new file mode 100644
index 0000000..1f66833
--- /dev/null
+++ b/tests/test_domain_randomization.py
@@ -0,0 +1,2469 @@
+"""Tests for the dr.* model-field randomization engine."""
+
+import math
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.entity import EntityCfg
+from mjlab.envs.mdp import dr
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.scene import Scene, SceneCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+from mjlab.utils.lab_api.math import quat_from_euler_xyz, quat_mul
+
+pytestmark = pytest.mark.filterwarnings(
+  "ignore:Use of index_put_ on expanded tensors is deprecated:UserWarning"
+)
+
+# Shared helpers.
+
+ROBOT_XML = """
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="base_geom" type="box" size="0.1 0.1 0.1" mass="1.0"
+        friction="0.5 0.01 0.005"/>
+      <site name="base_site" pos="0 0 0.1"/>
+      <camera name="front_cam" pos="0.5 0 0.3" xyaxes="0 -1 0 0 0 1" fovy="60"/>
+      <camera name="side_cam" pos="0 0.5 0.3" xyaxes="1 0 0 0 0 1" fovy="45"/>
+      <light name="top_light" pos="0 0 2" dir="0 0 -1"/>
+      <body name="foot1" pos="0.2 0 0">
+        <joint name="joint1" type="hinge" axis="0 0 1" range="0 1.57"/>
+        <geom name="foot1_geom" type="box" size="0.05 0.05 0.05" mass="0.1"
+          friction="0.5 0.01 0.005"/>
+      </body>
+      <body name="foot2" pos="-0.2 0 0">
+        <joint name="joint2" type="hinge" axis="0 0 1" range="0 1.57"/>
+        <geom name="foot2_geom" type="box" size="0.05 0.05 0.05" mass="0.1"
+          friction="0.5 0.01 0.005"/>
+      </body>
+      <body name="offset_body" pos="0 0.3 0">
+        <joint name="joint3" type="hinge" axis="1 0 0" range="-1.57 1.57"/>
+        <inertial pos="0.05 -0.02 0.03" mass="0.5"
+          fullinertia="0.001 0.002 0.0015 0.0001 -0.00005 0.00008"/>
+        <geom name="offset_geom" type="sphere" size="0.04"/>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+NUM_ENVS = 4
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+class Env:
+  def __init__(self, scene, sim, device):
+    self.scene = scene
+    self.sim = sim
+    self.num_envs = scene.num_envs
+    self.device = device
+
+
+def create_test_env(
+  device, num_envs=NUM_ENVS, expand_fields=("geom_friction", "dof_damping")
+):
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML))
+  scene_cfg = SceneCfg(num_envs=num_envs, entities={"robot": entity_cfg})
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+
+  sim = Simulation(num_envs=num_envs, cfg=SimulationCfg(), model=model, device=device)
+  scene.initialize(model, sim.model, sim.data)
+  if expand_fields:
+    sim.expand_model_fields(expand_fields)
+
+  return Env(scene, sim, device)
+
+
+@pytest.fixture(scope="module")
+def env(device):
+  return create_test_env(device)
+
+
+# Operations: abs, scale, add.
+
+
+def test_abs_operation(env):
+  """Values set directly within range, diversity across envs."""
+  torch.manual_seed(42)
+  robot = env.scene["robot"]
+
+  dr.geom_friction(
+    env,
+    env_ids=None,
+    ranges=(0.3, 1.2),
+    operation="abs",
+    asset_cfg=SceneEntityCfg("robot", geom_names=(".*",)),
+    axes=[0],
+  )
+
+  friction = env.sim.model.geom_friction[:, robot.indexing.geom_ids, 0]
+  assert torch.all((friction >= 0.3) & (friction <= 1.2))
+  assert len(torch.unique(friction)) >= 2
+
+
+def test_scale_operation(env):
+  """Values = default * sample, within expected bounds."""
+  torch.manual_seed(42)
+  robot = env.scene["robot"]
+  geom_idx = robot.indexing.geom_ids[0]
+
+  default_val = env.sim.get_default_field("geom_friction")[geom_idx, 0].item()
+
+  dr.geom_friction(
+    env,
+    env_ids=None,
+    ranges=(0.5, 2.0),
+    operation="scale",
+    asset_cfg=SceneEntityCfg("robot", geom_ids=[0]),
+    axes=[0],
+  )
+
+  result = env.sim.model.geom_friction[:, geom_idx, 0]
+  assert torch.all(
+    (result >= default_val * 0.5 - 1e-5) & (result <= default_val * 2.0 + 1e-5)
+  )
+
+
+def test_add_operation(env):
+  """Values = default + sample, within expected bounds."""
+  torch.manual_seed(42)
+  robot = env.scene["robot"]
+  geom_idx = robot.indexing.geom_ids[0]
+
+  default_val = env.sim.get_default_field("geom_friction")[geom_idx, 0].item()
+
+  dr.geom_friction(
+    env,
+    env_ids=None,
+    ranges=(-0.1, 0.1),
+    operation="add",
+    asset_cfg=SceneEntityCfg("robot", geom_ids=[0]),
+    axes=[0],
+  )
+
+  result = env.sim.model.geom_friction[:, geom_idx, 0]
+  assert torch.all(
+    (result >= default_val - 0.1 - 1e-5) & (result <= default_val + 0.1 + 1e-5)
+  )
+
+
+# No accumulation (scale and add share the same mechanism).
+
+
+@pytest.mark.parametrize(
+  "operation, fixed_val, expected_fn",
+  [
+    ("scale", (2.0, 2.0), lambda d: d * 2.0),
+    ("add", (0.1, 0.1), lambda d: d + 0.1),
+  ],
+)
+def test_no_accumulation(device, operation, fixed_val, expected_fn):
+  """3x with fixed value produces same result as 1x (uses defaults)."""
+  env = create_test_env(device, num_envs=2)
+  robot = env.scene["robot"]
+  geom_idx = robot.indexing.geom_ids[0]
+
+  default_friction = env.sim.get_default_field("geom_friction")[geom_idx, 0].item()
+
+  for _ in range(3):
+    dr.geom_friction(
+      env,
+      env_ids=None,
+      ranges=fixed_val,
+      operation=operation,
+      asset_cfg=SceneEntityCfg("robot", geom_ids=[0]),
+      axes=[0],
+    )
+
+  final = env.sim.model.geom_friction[0, geom_idx, 0].item()
+  assert abs(final - expected_fn(default_friction)) < 1e-5
+
+
+# Distributions.
+
+
+def test_log_uniform_distribution(device):
+  """Log-uniform produces values in [lo, hi], skewed toward lower."""
+  torch.manual_seed(42)
+  env = create_test_env(device, num_envs=64)
+
+  dr.geom_friction(
+    env,
+    env_ids=None,
+    ranges=(0.1, 10.0),
+    operation="abs",
+    distribution="log_uniform",
+    asset_cfg=SceneEntityCfg("robot", geom_ids=[0]),
+    axes=[0],
+  )
+
+  vals = env.sim.model.geom_friction[:, env.scene["robot"].indexing.geom_ids[0], 0]
+  assert torch.all((vals >= 0.1 - 1e-5) & (vals <= 10.0 + 1e-5))
+  # Geometric mean of log-uniform(0.1, 10) is 1.0, well below (0.1+10)/2=5.05.
+  assert vals.median() < (0.1 + 10.0) / 2
+
+
+def test_gaussian_distribution(device):
+  """Gaussian: mean/std interpretation, values cluster around mean."""
+  torch.manual_seed(42)
+  env = create_test_env(device, num_envs=128)
+
+  mean, std = 0.5, 0.05
+  dr.geom_friction(
+    env,
+    env_ids=None,
+    ranges=(mean, std),
+    operation="abs",
+    distribution="gaussian",
+    asset_cfg=SceneEntityCfg("robot", geom_ids=[0]),
+    axes=[0],
+  )
+
+  vals = env.sim.model.geom_friction[:, env.scene["robot"].indexing.geom_ids[0], 0]
+  assert abs(vals.mean().item() - mean) < 0.05
+
+
+# Axes.
+
+
+@pytest.mark.parametrize(
+  "axes, changed, unchanged",
+  [
+    (None, [0], [1, 2]),  # Default axes for geom_friction = [0]
+    ([1, 2], [1, 2], [0]),  # Explicit axes
+  ],
+)
+def test_axes_selectivity(device, axes, changed, unchanged):
+  """Only the specified axes are modified; others stay at defaults."""
+  env = create_test_env(device, num_envs=2)
+  robot = env.scene["robot"]
+  geom_idx = robot.indexing.geom_ids[0]
+
+  default_friction = env.sim.get_default_field("geom_friction")[geom_idx].clone()
+
+  dr.geom_friction(
+    env,
+    env_ids=None,
+    ranges=(2.0, 2.0),
+    operation="scale",
+    asset_cfg=SceneEntityCfg("robot", geom_ids=[0]),
+    axes=axes,
+  )
+
+  final = env.sim.model.geom_friction[0, geom_idx]
+  for ax in changed:
+    assert abs(final[ax] - default_friction[ax] * 2.0) < 1e-5
+  for ax in unchanged:
+    assert abs(final[ax] - default_friction[ax]) < 1e-5
+
+
+def test_dict_int_axis_ranges(device):
+  """{0: (lo, hi), 1: (lo2, hi2)} per-axis ranges."""
+  torch.manual_seed(42)
+  env = create_test_env(device, num_envs=2)
+  robot = env.scene["robot"]
+  geom_idx = robot.indexing.geom_ids[0]
+
+  dr.geom_friction(
+    env,
+    env_ids=None,
+    ranges={0: (0.3, 0.4), 1: (0.001, 0.002)},
+    operation="abs",
+    asset_cfg=SceneEntityCfg("robot", geom_ids=[0]),
+  )
+
+  final = env.sim.model.geom_friction[0, geom_idx]
+  assert 0.3 - 1e-5 <= final[0].item() <= 0.4 + 1e-5
+  assert 0.001 - 1e-5 <= final[1].item() <= 0.002 + 1e-5
+
+
+def test_invalid_axes_raises(env):
+  """axes outside valid_axes raises ValueError."""
+  with pytest.raises(ValueError, match="Invalid axes"):
+    dr.geom_friction(
+      env,
+      env_ids=None,
+      ranges=(0.3, 1.2),
+      operation="abs",
+      asset_cfg=SceneEntityCfg("robot", geom_names=(".*",)),
+      axes=[3],  # geom_friction valid_axes=[0,1,2]
+    )
+
+
+# String-keyed ranges.
+
+
+def test_string_keyed_ranges(env):
+  """Per-component DR with regex patterns."""
+  torch.manual_seed(42)
+  dr.joint_damping(
+    env,
+    env_ids=None,
+    ranges={".*joint1": (0.5, 0.5), ".*joint2": (1.5, 1.5)},
+    operation="abs",
+    asset_cfg=SceneEntityCfg("robot", joint_names=(".*",)),
+  )
+
+  robot = env.scene["robot"]
+  dof_adr = robot.indexing.joint_v_adr
+  damping = env.sim.model.dof_damping[0, dof_adr]
+  assert abs(damping[0].item() - 0.5) < 1e-5
+  assert abs(damping[1].item() - 1.5) < 1e-5
+
+
+def test_string_keyed_ranges_no_match_raises(env):
+  """Pattern matching no names raises ValueError."""
+  with pytest.raises(ValueError, match="matched no"):
+    dr.joint_damping(
+      env,
+      env_ids=None,
+      ranges={"nonexistent_joint": (0.5, 1.5)},
+      operation="abs",
+      asset_cfg=SceneEntityCfg("robot", joint_names=(".*",)),
+    )
+
+
+# Shared random.
+
+
+def test_shared_random(env):
+  """All entities within same env get same value, envs differ."""
+  torch.manual_seed(42)
+  robot = env.scene["robot"]
+  geom_ids = robot.indexing.geom_ids
+
+  dr.geom_friction(
+    env,
+    env_ids=None,
+    ranges=(0.3, 1.2),
+    operation="abs",
+    asset_cfg=SceneEntityCfg("robot", geom_names=(".*",)),
+    axes=[0],
+    shared_random=True,
+  )
+
+  friction = env.sim.model.geom_friction[:, geom_ids, 0]
+
+  for env_idx in range(env.num_envs):
+    env_friction = friction[env_idx]
+    assert torch.allclose(env_friction, env_friction[0].expand_as(env_friction))
+
+  env_frictions = friction[:, 0]
+  assert len(torch.unique(env_frictions)) > 1
+  assert torch.all((friction >= 0.3) & (friction <= 1.2))
+
+
+# Edge cases.
+
+
+def test_single_env_without_expand(device):
+  """num_envs=1 works without expand_model_fields, no accumulation."""
+  env = create_test_env(device, num_envs=1, expand_fields=())
+  robot = env.scene["robot"]
+  geom_idx = robot.indexing.geom_ids[0]
+
+  original_friction = env.sim.model.geom_friction[0, geom_idx, 0].item()
+
+  for _ in range(2):
+    dr.geom_friction(
+      env,
+      env_ids=None,
+      ranges=(2.0, 2.0),
+      operation="scale",
+      asset_cfg=SceneEntityCfg("robot", geom_ids=[0]),
+      axes=[0],
+    )
+
+  final = env.sim.model.geom_friction[0, geom_idx, 0].item()
+  assert abs(final - original_friction * 2.0) < 1e-5
+
+
+def test_partial_env_ids(env):
+  """Randomizing subset of envs leaves others unchanged."""
+  torch.manual_seed(42)
+  robot = env.scene["robot"]
+  geom_idx = robot.indexing.geom_ids[0]
+
+  original = env.sim.model.geom_friction[:, geom_idx, 0].clone()
+
+  dr.geom_friction(
+    env,
+    env_ids=torch.tensor([0, 2], device=env.device),
+    ranges=(0.1, 0.2),
+    operation="abs",
+    asset_cfg=SceneEntityCfg("robot", geom_ids=[0]),
+    axes=[0],
+  )
+
+  result = env.sim.model.geom_friction[:, geom_idx, 0]
+  # Envs 0,2 should have changed.
+  assert torch.all((result[0] >= 0.1) & (result[0] <= 0.2))
+  assert torch.all((result[2] >= 0.1) & (result[2] <= 0.2))
+  # Envs 1,3 should be unchanged.
+  assert result[1] == original[1]
+  assert result[3] == original[3]
+
+
+# CUDA graph.
+
+
+@pytest.mark.skipif(
+  not torch.cuda.is_available(), reason="CUDA required for graph capture"
+)
+def test_expand_model_fields_recreates_cuda_graph(device):
+  """Verify CUDA graph is recreated after expand_model_fields."""
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML))
+  scene_cfg = SceneCfg(num_envs=NUM_ENVS, entities={"robot": entity_cfg})
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+
+  sim = Simulation(num_envs=NUM_ENVS, cfg=SimulationCfg(), model=model, device=device)
+  scene.initialize(model, sim.model, sim.data)
+
+  if not sim.use_cuda_graph:
+    pytest.skip("CUDA graph capture not enabled on this device")
+
+  original_step_graph = sim.step_graph
+
+  sim.expand_model_fields(("geom_friction",))
+
+  assert sim.step_graph is not original_step_graph, (
+    "CUDA graph was not recreated after expand_model_fields"
+  )
+
+
+# Integration test.
+
+
+@pytest.mark.slow
+def test_g1_foot_friction_shared_across_geoms(device):
+  """G1 velocity env has uniform foot friction across all collision geoms."""
+  import io
+  import warnings
+  from contextlib import redirect_stderr, redirect_stdout
+
+  from mjlab.envs.manager_based_rl_env import ManagerBasedRlEnv
+  from mjlab.tasks.velocity.config.g1.env_cfgs import unitree_g1_flat_env_cfg
+
+  cfg = unitree_g1_flat_env_cfg()
+
+  with warnings.catch_warnings():
+    warnings.simplefilter("ignore")
+    with redirect_stdout(io.StringIO()), redirect_stderr(io.StringIO()):
+      env = ManagerBasedRlEnv(cfg, device=device)
+
+  try:
+    robot = env.scene["robot"]
+
+    foot_geom_names = [
+      f"{side}_foot{i}_collision" for side in ("left", "right") for i in range(1, 8)
+    ]
+    foot_geom_ids, _ = robot.find_geoms(foot_geom_names)
+    foot_geom_indices = robot.indexing.geom_ids[foot_geom_ids]
+
+    friction = env.sim.model.geom_friction[:, foot_geom_indices, 0]
+
+    for env_idx in range(env.num_envs):
+      env_friction = friction[env_idx]
+      assert torch.allclose(env_friction, env_friction[0].expand_as(env_friction))
+
+    if env.num_envs > 1:
+      env_frictions = friction[:, 0]
+      assert len(torch.unique(env_frictions)) > 1
+  finally:
+    env.close()
+
+
+# Quaternion DR tests.
+
+
+def _make_quat_env(device, num_envs=NUM_ENVS):
+  """Create an env with body_quat, geom_quat, site_quat expanded."""
+  return create_test_env(
+    device,
+    num_envs=num_envs,
+    expand_fields=("body_quat", "geom_quat", "site_quat"),
+  )
+
+
+@pytest.fixture(scope="module")
+def quat_env(device):
+  return _make_quat_env(device)
+
+
+_QUAT_CASES = [
+  pytest.param(
+    dr.body_quat,
+    "body_quat",
+    SceneEntityCfg("robot", body_names=(".*",)),
+    "body_ids",
+    id="body",
+  ),
+  pytest.param(
+    dr.geom_quat,
+    "geom_quat",
+    SceneEntityCfg("robot", geom_names=(".*",)),
+    "geom_ids",
+    id="geom",
+  ),
+  pytest.param(
+    dr.site_quat,
+    "site_quat",
+    SceneEntityCfg("robot", site_names=(".*",)),
+    "site_ids",
+    id="site",
+  ),
+]
+
+
+@pytest.mark.parametrize("dr_func, field, asset_cfg, ids_attr", _QUAT_CASES)
+def test_quat_is_unit_quaternion(quat_env, dr_func, field, asset_cfg, ids_attr):
+  """All output quaternions must have unit norm (within 1e-6)."""
+  torch.manual_seed(0)
+  env = quat_env
+  robot = env.scene["robot"]
+
+  dr_func(
+    env,
+    env_ids=None,
+    roll_range=(-0.5, 0.5),
+    pitch_range=(-0.5, 0.5),
+    yaw_range=(-math.pi, math.pi),
+    asset_cfg=asset_cfg,
+  )
+
+  ids = getattr(robot.indexing, ids_attr)
+  quats = getattr(env.sim.model, field)[:, ids, :]
+  norms = quats.norm(dim=-1)
+  assert torch.all((norms - 1.0).abs() < 1e-6), (
+    f"Non-unit quaternion found; max deviation: {(norms - 1.0).abs().max()}"
+  )
+
+
+@pytest.mark.parametrize("dr_func, field, asset_cfg, ids_attr", _QUAT_CASES)
+def test_quat_zero_range_unchanged(quat_env, dr_func, field, asset_cfg, ids_attr):
+  """All ranges (0, 0): result equals default quaternion."""
+  env = quat_env
+  robot = env.scene["robot"]
+  ids = getattr(robot.indexing, ids_attr)
+  default_quat = env.sim.get_default_field(field)[ids].clone()
+
+  dr_func(env, env_ids=None, asset_cfg=asset_cfg)
+
+  result = getattr(env.sim.model, field)[:, ids, :]
+  assert torch.allclose(result, default_quat.unsqueeze(0).expand_as(result), atol=1e-6)
+
+
+@pytest.mark.parametrize("dr_func, field, asset_cfg, ids_attr", _QUAT_CASES)
+def test_quat_composes_with_default(quat_env, dr_func, field, asset_cfg, ids_attr):
+  """Fixed yaw=pi/4 matches manual quat_mul(q_yaw, q_default)."""
+  env = quat_env
+  robot = env.scene["robot"]
+  ids = getattr(robot.indexing, ids_attr)
+  n = len(ids)
+
+  yaw = math.pi / 4
+  dr_func(env, env_ids=None, yaw_range=(yaw, yaw), asset_cfg=asset_cfg)
+
+  result = getattr(env.sim.model, field)[:, ids, :]
+  q_default = env.sim.get_default_field(field)[ids]
+  zeros = torch.zeros(n, device=env.device)
+  q_yaw = quat_from_euler_xyz(zeros, zeros, zeros + yaw)
+  q_expected = quat_mul(q_yaw, q_default)
+  assert torch.allclose(result, q_expected.unsqueeze(0).expand_as(result), atol=1e-6)
+
+
+def test_body_quat_only_specified_axes(quat_env):
+  """Yaw-only perturbation: roll/pitch of result match default."""
+  torch.manual_seed(1)
+  env = quat_env
+  robot = env.scene["robot"]
+  body_cfg = SceneEntityCfg("robot", body_names=("base",))
+  body_cfg.resolve(env.scene)
+  body_ids = robot.indexing.body_ids[body_cfg.body_ids]
+
+  dr.body_quat(
+    env,
+    env_ids=None,
+    yaw_range=(-0.3, 0.3),
+    asset_cfg=SceneEntityCfg("robot", body_names=("base",)),
+  )
+
+  result = env.sim.model.body_quat[:, body_ids, :]
+  # For the default quat [1,0,0,0] composed with a yaw-only rotation, qx and qy should
+  # remain 0 (pure yaw -> no roll/pitch).
+  q_default = env.sim.get_default_field("body_quat")[body_ids]
+  if torch.allclose(q_default, torch.tensor([[1.0, 0.0, 0.0, 0.0]], device=env.device)):
+    assert torch.allclose(result[..., 1], torch.zeros_like(result[..., 1]), atol=1e-6)
+    assert torch.allclose(result[..., 2], torch.zeros_like(result[..., 2]), atol=1e-6)
+
+
+# pseudo_inertia tests.
+
+
+def _make_inertia_env(device, num_envs=NUM_ENVS):
+  """Create an env with all inertia-related fields expanded."""
+  return create_test_env(
+    device,
+    num_envs=num_envs,
+    expand_fields=("body_mass", "body_ipos", "body_inertia", "body_iquat"),
+  )
+
+
+@pytest.fixture(scope="module")
+def inertia_env(device):
+  return _make_inertia_env(device)
+
+
+def _matrix_from_quat(q: torch.Tensor) -> torch.Tensor:
+  """Convert wxyz quaternion(s) to 3x3 rotation matrix.
+
+  Shape: (..., 4) → (..., 3, 3).
+  """
+  w, x, y, z = q[..., 0], q[..., 1], q[..., 2], q[..., 3]
+  return torch.stack(
+    [
+      torch.stack(
+        [1 - 2 * (y * y + z * z), 2 * (x * y - z * w), 2 * (x * z + y * w)], dim=-1
+      ),
+      torch.stack(
+        [2 * (x * y + z * w), 1 - 2 * (x * x + z * z), 2 * (y * z - x * w)], dim=-1
+      ),
+      torch.stack(
+        [2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x * x + y * y)], dim=-1
+      ),
+    ],
+    dim=-2,
+  )
+
+
+def _reconstruct_J(mass, ipos, inertia, iquat):
+  """Reconstruct pseudo-inertia matrix from MuJoCo fields (test helper).
+
+  Correctly accounts for body_iquat (the principal-frame rotation) and the
+  parallel-axis theorem (body_ipos) so that the reconstructed J is exact regardless of
+  shear magnitude.
+  """
+  I3 = torch.eye(3, device=mass.device, dtype=mass.dtype)
+  # MuJoCo body_iquat maps principal→body.
+  R = _matrix_from_quat(iquat)  # (..., 3, 3)
+  # Inertia tensor at COM in body frame: I_com = R @ diag(inertia) @ R^T
+  I_com = R @ torch.diag_embed(inertia) @ R.mT  # (..., 3, 3)
+
+  # Parallel-axis theorem: shift from COM to body origin.
+  c = ipos  # (..., 3)
+  c_sq = (c * c).sum(dim=-1)  # (...,)
+  c_outer = c.unsqueeze(-1) * c.unsqueeze(-2)  # (..., 3, 3)
+  m = mass.unsqueeze(-1).unsqueeze(-1)  # (..., 1, 1)
+  I_origin = I_com + m * (c_sq.unsqueeze(-1).unsqueeze(-1) * I3 - c_outer)
+
+  trace = I_origin.diagonal(dim1=-2, dim2=-1).sum(dim=-1)
+  sigma = 0.5 * trace.unsqueeze(-1).unsqueeze(-1) * I3 - I_origin
+  h = mass.unsqueeze(-1) * ipos
+  batch = mass.shape
+  J = torch.zeros(*batch, 4, 4, device=mass.device, dtype=mass.dtype)
+  J[..., :3, :3] = sigma
+  J[..., :3, 3] = h
+  J[..., 3, :3] = h
+  J[..., 3, 3] = mass
+  return J
+
+
+def test_pseudo_inertia_physical_consistency(inertia_env):
+  """After wide perturbation, J ≻ 0, mass > 0, triangle inequality holds."""
+  torch.manual_seed(10)
+  env = inertia_env
+  robot = env.scene["robot"]
+  body_cfg = SceneEntityCfg("robot", body_names=("base", "foot1", "foot2"))
+  body_cfg.resolve(env.scene)
+
+  dr.pseudo_inertia(
+    env,
+    env_ids=None,
+    alpha_range=(-0.5, 0.5),
+    d_range=(-0.3, 0.3),
+    s12_range=(-0.1, 0.1),
+    s13_range=(-0.1, 0.1),
+    s23_range=(-0.1, 0.1),
+    t_range=(-0.05, 0.05),
+    asset_cfg=body_cfg,
+  )
+
+  body_ids = robot.indexing.body_ids[body_cfg.body_ids]
+  mass = env.sim.model.body_mass[:, body_ids]
+  ipos = env.sim.model.body_ipos[:, body_ids, :]
+  inertia = env.sim.model.body_inertia[:, body_ids, :]
+  iquat = env.sim.model.body_iquat[:, body_ids, :]
+
+  # Mass must be positive.
+  assert torch.all(mass > 0), f"Non-positive mass: {mass.min()}"
+
+  # Principal moments must all be positive.
+  assert torch.all(inertia > 0), f"Non-positive principal moment: {inertia.min()}"
+
+  # body_iquat must be a unit quaternion.
+  iquat_norms = iquat.norm(dim=-1)
+  assert torch.all((iquat_norms - 1.0).abs() < 1e-5), (
+    f"Non-unit body_iquat; max deviation: {(iquat_norms - 1.0).abs().max()}"
+  )
+
+  # Triangle inequality on principal moments: D_i + D_j >= D_k.
+  d1, d2, d3 = inertia[..., 0], inertia[..., 1], inertia[..., 2]
+  assert torch.all(d1 + d2 >= d3 - 1e-6)
+  assert torch.all(d1 + d3 >= d2 - 1e-6)
+  assert torch.all(d2 + d3 >= d1 - 1e-6)
+
+  # Round-trip check: reconstruct J from all four stored fields (including body_iquat)
+  # and verify it is positive definite. This is exact because the implementation writes
+  # the eigendecomposition of J'.
+  J = _reconstruct_J(mass, ipos, inertia, iquat)
+  eigvals = torch.linalg.eigvalsh(J)
+  assert torch.all(eigvals > -1e-5), f"Non-positive J eigenvalue: {eigvals.min()}"
+
+
+def test_pseudo_inertia_zero_perturbation_unchanged(inertia_env):
+  """All ranges (0, 0): mass, ipos, inertia, iquat equal defaults (1e-5)."""
+  env = inertia_env
+  robot = env.scene["robot"]
+  body_cfg = SceneEntityCfg("robot", body_names=("base", "foot1", "foot2"))
+  body_cfg.resolve(env.scene)
+  body_ids = robot.indexing.body_ids[body_cfg.body_ids]
+
+  def_mass = env.sim.get_default_field("body_mass")[body_ids].clone()
+  def_ipos = env.sim.get_default_field("body_ipos")[body_ids].clone()
+  def_inertia = env.sim.get_default_field("body_inertia")[body_ids].clone()
+  def_iquat = env.sim.get_default_field("body_iquat")[body_ids].clone()
+
+  dr.pseudo_inertia(env, env_ids=None, asset_cfg=body_cfg)
+
+  mass = env.sim.model.body_mass[:, body_ids]
+  ipos = env.sim.model.body_ipos[:, body_ids, :]
+  inertia = env.sim.model.body_inertia[:, body_ids, :]
+  iquat = env.sim.model.body_iquat[:, body_ids, :]
+
+  assert torch.allclose(mass, def_mass.unsqueeze(0).expand_as(mass), atol=1e-5)
+  assert torch.allclose(ipos, def_ipos.unsqueeze(0).expand_as(ipos), atol=1e-5)
+  # For bodies with degenerate eigenvalues (2+ equal principal moments), the
+  # eigenvector basis is non-unique, so the (inertia, iquat) decomposition may differ
+  # while producing the same physical inertia tensor. Compare the full tensor
+  # R @ diag(inertia) @ R^T rather than individual components.
+  R_def = _matrix_from_quat(def_iquat)
+  I_def = R_def @ torch.diag_embed(def_inertia) @ R_def.mT
+  R_new = _matrix_from_quat(iquat)
+  I_new = R_new @ torch.diag_embed(inertia) @ R_new.mT
+  assert torch.allclose(I_new, I_def.unsqueeze(0).expand_as(I_new), atol=1e-5), (
+    "Inertia tensor changed unexpectedly under zero perturbation"
+  )
+
+
+def test_pseudo_inertia_zero_perturbation_offset_body(inertia_env):
+  """Zero perturbation preserves physics for a body with non-trivial ipos/iquat.
+
+  Since ``eigh`` returns eigenvalues in ascending order while MuJoCo may store them
+  differently, we compare the reconstructed pseudo-inertia matrix J (which is
+  representation-independent) rather than the raw principal moments and iquat
+  individually.
+  """
+  env = inertia_env
+  robot = env.scene["robot"]
+  body_cfg = SceneEntityCfg("robot", body_names=("offset_body",))
+  body_cfg.resolve(env.scene)
+  body_ids = robot.indexing.body_ids[body_cfg.body_ids]
+
+  def_mass = env.sim.get_default_field("body_mass")[body_ids].clone()
+  def_ipos = env.sim.get_default_field("body_ipos")[body_ids].clone()
+  def_inertia = env.sim.get_default_field("body_inertia")[body_ids].clone()
+  def_iquat = env.sim.get_default_field("body_iquat")[body_ids].clone()
+
+  # Verify the test body actually has non-trivial ipos and iquat.
+  assert not torch.allclose(def_ipos, torch.zeros_like(def_ipos), atol=1e-6), (
+    "Test body should have non-zero ipos"
+  )
+  identity_q = torch.tensor([1.0, 0.0, 0.0, 0.0], device=env.device)
+  assert not (
+    torch.allclose(def_iquat, identity_q.expand_as(def_iquat), atol=1e-6)
+    or torch.allclose(def_iquat, -identity_q.expand_as(def_iquat), atol=1e-6)
+  ), "Test body should have non-identity iquat"
+
+  dr.pseudo_inertia(env, env_ids=None, asset_cfg=body_cfg)
+
+  mass = env.sim.model.body_mass[:, body_ids]
+  ipos = env.sim.model.body_ipos[:, body_ids, :]
+  inertia = env.sim.model.body_inertia[:, body_ids, :]
+  iquat = env.sim.model.body_iquat[:, body_ids, :]
+
+  # Mass and ipos must be exactly preserved.
+  assert torch.allclose(mass, def_mass.unsqueeze(0).expand_as(mass), atol=1e-5)
+  assert torch.allclose(ipos, def_ipos.unsqueeze(0).expand_as(ipos), atol=1e-5)
+
+  # Inertia and iquat may have different eigenvalue ordering, so compare the
+  # reconstructed J matrix instead.
+  J_default = _reconstruct_J(def_mass, def_ipos, def_inertia, def_iquat)
+  J_result = _reconstruct_J(mass, ipos, inertia, iquat)
+  assert torch.allclose(
+    J_result, J_default.unsqueeze(0).expand_as(J_result), atol=1e-5
+  ), (
+    f"Reconstructed J differs under zero perturbation.\n"
+    f"Max deviation: {(J_result - J_default.unsqueeze(0)).abs().max()}"
+  )
+
+
+def test_pseudo_inertia_alpha_only_scales_mass(inertia_env):
+  """alpha-only: mass and inertia scale by e^{2α}, ipos unchanged."""
+  env = inertia_env
+  robot = env.scene["robot"]
+  body_cfg = SceneEntityCfg("robot", body_names=("base", "foot1", "foot2"))
+  body_cfg.resolve(env.scene)
+  body_ids = robot.indexing.body_ids[body_cfg.body_ids]
+
+  a = 0.3
+  scale = math.exp(2 * a)
+
+  def_mass = env.sim.get_default_field("body_mass")[body_ids].clone()
+  def_ipos = env.sim.get_default_field("body_ipos")[body_ids].clone()
+  def_inertia = env.sim.get_default_field("body_inertia")[body_ids].clone()
+
+  dr.pseudo_inertia(env, env_ids=None, alpha_range=(a, a), asset_cfg=body_cfg)
+
+  mass = env.sim.model.body_mass[:, body_ids]
+  ipos = env.sim.model.body_ipos[:, body_ids, :]
+  inertia = env.sim.model.body_inertia[:, body_ids, :]
+
+  expected_mass = def_mass * scale
+  expected_inertia = def_inertia * scale
+
+  assert torch.allclose(mass, expected_mass.unsqueeze(0).expand_as(mass), atol=1e-5)
+  assert torch.allclose(
+    inertia, expected_inertia.unsqueeze(0).expand_as(inertia), atol=1e-5
+  )
+  assert torch.allclose(ipos, def_ipos.unsqueeze(0).expand_as(ipos), atol=1e-5)
+
+
+def test_pseudo_inertia_t1_shifts_com(inertia_env):
+  """t1-only: mass unchanged, ipos[0] shifts by exactly t1."""
+  env = inertia_env
+  robot = env.scene["robot"]
+  body_cfg = SceneEntityCfg("robot", body_names=("base", "foot1", "foot2"))
+  body_cfg.resolve(env.scene)
+  body_ids = robot.indexing.body_ids[body_cfg.body_ids]
+
+  t = 0.05
+  def_mass = env.sim.get_default_field("body_mass")[body_ids].clone()
+  def_ipos = env.sim.get_default_field("body_ipos")[body_ids].clone()
+
+  dr.pseudo_inertia(env, env_ids=None, t1_range=(t, t), asset_cfg=body_cfg)
+
+  mass = env.sim.model.body_mass[:, body_ids]
+  ipos = env.sim.model.body_ipos[:, body_ids, :]
+
+  assert torch.allclose(mass, def_mass.unsqueeze(0).expand_as(mass), atol=1e-5)
+  # ipos x-component shifts by t; y and z are unchanged.
+  assert torch.allclose(
+    ipos[..., 0], (def_ipos[..., 0] + t).unsqueeze(0).expand_as(ipos[..., 0]), atol=1e-5
+  )
+  assert torch.allclose(
+    ipos[..., 1:], def_ipos[..., 1:].unsqueeze(0).expand_as(ipos[..., 1:]), atol=1e-5
+  )
+
+
+def test_pseudo_inertia_d_isotropic_vs_per_axis(device):
+  """d_range=(r,r) gives same result as d1=d2=d3=(r,r)."""
+  r = 0.2
+  seed = 42
+
+  torch.manual_seed(seed)
+  env1 = _make_inertia_env(device)
+  body_cfg = SceneEntityCfg("robot", body_names=("base", "foot1", "foot2"))
+  body_cfg.resolve(env1.scene)
+  dr.pseudo_inertia(env1, env_ids=None, d_range=(r, r), asset_cfg=body_cfg)
+
+  torch.manual_seed(seed)
+  env2 = _make_inertia_env(device)
+  dr.pseudo_inertia(
+    env2,
+    env_ids=None,
+    d1_range=(r, r),
+    d2_range=(r, r),
+    d3_range=(r, r),
+    asset_cfg=body_cfg,
+  )
+
+  robot1 = env1.scene["robot"]
+  body_ids = robot1.indexing.body_ids[body_cfg.body_ids]
+
+  assert torch.allclose(
+    env1.sim.model.body_mass[:, body_ids],
+    env2.sim.model.body_mass[:, body_ids],
+    atol=1e-6,
+  )
+  assert torch.allclose(
+    env1.sim.model.body_inertia[:, body_ids, :],
+    env2.sim.model.body_inertia[:, body_ids, :],
+    atol=1e-6,
+  )
+
+
+def test_pseudo_inertia_no_accumulation(device):
+  """3x with alpha=0.1 gives same result as 1x (uses defaults each time)."""
+  env = _make_inertia_env(device)
+  robot = env.scene["robot"]
+  body_cfg = SceneEntityCfg("robot", body_names=("base",))
+  body_cfg.resolve(env.scene)
+  body_ids = robot.indexing.body_ids[body_cfg.body_ids]
+
+  for _ in range(3):
+    dr.pseudo_inertia(env, env_ids=None, alpha_range=(0.1, 0.1), asset_cfg=body_cfg)
+
+  mass_3x = env.sim.model.body_mass[:, body_ids].clone()
+
+  env2 = _make_inertia_env(device)
+  dr.pseudo_inertia(env2, env_ids=None, alpha_range=(0.1, 0.1), asset_cfg=body_cfg)
+  mass_1x = env2.sim.model.body_mass[:, body_ids]
+
+  assert torch.allclose(mass_3x, mass_1x, atol=1e-5)
+
+
+def test_pseudo_inertia_partial_env_ids(device):
+  """Randomizing only env 0 leaves env 1 unchanged."""
+  env = _make_inertia_env(device, num_envs=2)
+  robot = env.scene["robot"]
+  body_cfg = SceneEntityCfg("robot", body_names=("base",))
+  body_cfg.resolve(env.scene)
+  body_ids = robot.indexing.body_ids[body_cfg.body_ids]
+
+  mass_before = env.sim.model.body_mass[:, body_ids].clone()
+
+  dr.pseudo_inertia(
+    env,
+    env_ids=torch.tensor([0], device=device),
+    alpha_range=(0.5, 0.5),
+    asset_cfg=body_cfg,
+  )
+
+  mass_after = env.sim.model.body_mass[:, body_ids]
+  # Env 0 changed.
+  assert not torch.allclose(mass_after[0], mass_before[0], atol=1e-6)
+  # Env 1 unchanged.
+  assert torch.allclose(mass_after[1], mass_before[1], atol=1e-6)
+
+
+# Camera / Light DR tests.
+
+
+def _make_cam_light_env(device, num_envs=NUM_ENVS):
+  """Create an env with camera and light fields expanded."""
+  return create_test_env(
+    device,
+    num_envs=num_envs,
+    expand_fields=(
+      "cam_fovy",
+      "cam_pos",
+      "cam_quat",
+      "cam_intrinsic",
+      "light_pos",
+      "light_dir",
+      "light_diffuse",
+      "light_specular",
+      "light_ambient",
+      "light_attenuation",
+      "light_cutoff",
+      "light_exponent",
+    ),
+  )
+
+
+@pytest.fixture(scope="module")
+def cam_light_env(device):
+  return _make_cam_light_env(device)
+
+
+def test_cam_fovy_abs(cam_light_env):
+  """Set fovy to absolute range, check bounds."""
+  torch.manual_seed(42)
+  env = cam_light_env
+  robot = env.scene["robot"]
+  cam_cfg = SceneEntityCfg("robot", camera_names=(".*",))
+  cam_cfg.resolve(env.scene)
+  cam_ids = robot.indexing.cam_ids[cam_cfg.camera_ids]
+
+  dr.cam_fovy(
+    env,
+    env_ids=None,
+    ranges=(30.0, 90.0),
+    operation="abs",
+    asset_cfg=cam_cfg,
+  )
+
+  fovy = env.sim.model.cam_fovy[:, cam_ids]
+  assert torch.all((fovy >= 30.0 - 1e-3) & (fovy <= 90.0 + 1e-3))
+
+
+def test_cam_pos_add(cam_light_env):
+  """Add offset to camera positions, check default + offset."""
+  torch.manual_seed(42)
+  env = cam_light_env
+  robot = env.scene["robot"]
+  cam_cfg = SceneEntityCfg("robot", camera_names=("front_cam",))
+  cam_cfg.resolve(env.scene)
+  cam_ids = robot.indexing.cam_ids[cam_cfg.camera_ids]
+
+  default_pos = env.sim.get_default_field("cam_pos")[cam_ids].clone()
+
+  dr.cam_pos(
+    env,
+    env_ids=None,
+    ranges=(-0.1, 0.1),
+    operation="add",
+    asset_cfg=cam_cfg,
+  )
+
+  result = env.sim.model.cam_pos[:, cam_ids, :]
+  for ax in range(3):
+    lo = default_pos[..., ax] - 0.1 - 1e-5
+    hi = default_pos[..., ax] + 0.1 + 1e-5
+    assert torch.all((result[..., ax] >= lo) & (result[..., ax] <= hi))
+
+
+def test_cam_quat_zero_unchanged(cam_light_env):
+  """Zero RPY range preserves default quaternion."""
+  env = cam_light_env
+  robot = env.scene["robot"]
+  cam_cfg = SceneEntityCfg("robot", camera_names=(".*",))
+  cam_cfg.resolve(env.scene)
+  cam_ids = robot.indexing.cam_ids[cam_cfg.camera_ids]
+
+  default_quat = env.sim.get_default_field("cam_quat")[cam_ids].clone()
+
+  dr.cam_quat(env, env_ids=None, asset_cfg=cam_cfg)
+
+  result = env.sim.model.cam_quat[:, cam_ids, :]
+  assert torch.allclose(
+    result,
+    default_quat.unsqueeze(0).expand_as(result),
+    atol=1e-6,
+  )
+
+
+def test_light_pos_abs(cam_light_env):
+  """Set light position to absolute range, check bounds."""
+  torch.manual_seed(42)
+  env = cam_light_env
+  robot = env.scene["robot"]
+  light_cfg = SceneEntityCfg("robot", light_names=(".*",))
+  light_cfg.resolve(env.scene)
+  light_ids = robot.indexing.light_ids[light_cfg.light_ids]
+
+  dr.light_pos(
+    env,
+    env_ids=None,
+    ranges=(-5.0, 5.0),
+    operation="abs",
+    asset_cfg=light_cfg,
+  )
+
+  pos = env.sim.model.light_pos[:, light_ids, :]
+  assert torch.all((pos >= -5.0 - 1e-3) & (pos <= 5.0 + 1e-3))
+
+
+def test_light_dir_add(cam_light_env):
+  """Add offset to light direction, check default + offset."""
+  torch.manual_seed(42)
+  env = cam_light_env
+  robot = env.scene["robot"]
+  light_cfg = SceneEntityCfg("robot", light_names=(".*",))
+  light_cfg.resolve(env.scene)
+  light_ids = robot.indexing.light_ids[light_cfg.light_ids]
+
+  default_dir = env.sim.get_default_field("light_dir")[light_ids].clone()
+
+  dr.light_dir(
+    env,
+    env_ids=None,
+    ranges=(-0.5, 0.5),
+    operation="add",
+    asset_cfg=light_cfg,
+  )
+
+  result = env.sim.model.light_dir[:, light_ids, :]
+  for ax in range(3):
+    lo = default_dir[..., ax] - 0.5 - 1e-5
+    hi = default_dir[..., ax] + 0.5 + 1e-5
+    assert torch.all((result[..., ax] >= lo) & (result[..., ax] <= hi))
+
+
+@pytest.mark.parametrize(
+  ("func_name", "field", "ranges"),
+  [
+    ("light_diffuse", "light_diffuse", (0.2, 0.8)),
+    ("light_specular", "light_specular", (0.0, 1.0)),
+    ("light_ambient", "light_ambient", (0.1, 0.5)),
+    ("light_attenuation", "light_attenuation", (0.0, 1.0)),
+  ],
+)
+def test_light_vec3_fields_abs(cam_light_env, func_name, field, ranges):
+  """Vec3 light fields randomize per selected light."""
+  torch.manual_seed(42)
+  env = cam_light_env
+  robot = env.scene["robot"]
+  light_cfg = SceneEntityCfg("robot", light_names=(".*",))
+  light_cfg.resolve(env.scene)
+  light_ids = robot.indexing.light_ids[light_cfg.light_ids]
+  func = getattr(dr, func_name)
+
+  func(
+    env,
+    env_ids=None,
+    ranges=ranges,
+    operation="abs",
+    asset_cfg=light_cfg,
+  )
+
+  values = getattr(env.sim.model, field)[:, light_ids, :]
+  lower, upper = ranges
+  assert torch.all((values >= lower - 1e-5) & (values <= upper + 1e-5))
+  assert len(torch.unique(values[:, 0, 0])) >= 2
+
+
+@pytest.mark.parametrize(
+  ("func_name", "field", "ranges"),
+  [
+    ("light_cutoff", "light_cutoff", (20.0, 60.0)),
+    ("light_exponent", "light_exponent", (1.0, 20.0)),
+  ],
+)
+def test_light_scalar_fields_abs(cam_light_env, func_name, field, ranges):
+  """Scalar light fields randomize per selected light."""
+  torch.manual_seed(42)
+  env = cam_light_env
+  robot = env.scene["robot"]
+  light_cfg = SceneEntityCfg("robot", light_names=(".*",))
+  light_cfg.resolve(env.scene)
+  light_ids = robot.indexing.light_ids[light_cfg.light_ids]
+  func = getattr(dr, func_name)
+
+  func(
+    env,
+    env_ids=None,
+    ranges=ranges,
+    operation="abs",
+    asset_cfg=light_cfg,
+  )
+
+  values = getattr(env.sim.model, field)[:, light_ids]
+  lower, upper = ranges
+  assert torch.all((values >= lower - 1e-5) & (values <= upper + 1e-5))
+  assert len(torch.unique(values[:, 0])) >= 2
+
+
+def test_camera_partial_env_ids(cam_light_env):
+  """Subset of envs randomized, others unchanged."""
+  torch.manual_seed(42)
+  env = cam_light_env
+  robot = env.scene["robot"]
+  cam_cfg = SceneEntityCfg("robot", camera_names=(".*",))
+  cam_cfg.resolve(env.scene)
+  cam_ids = robot.indexing.cam_ids[cam_cfg.camera_ids]
+
+  original_fovy = env.sim.model.cam_fovy[:, cam_ids].clone()
+
+  dr.cam_fovy(
+    env,
+    env_ids=torch.tensor([0, 2], device=env.device),
+    ranges=(10.0, 20.0),
+    operation="abs",
+    asset_cfg=cam_cfg,
+  )
+
+  result = env.sim.model.cam_fovy[:, cam_ids]
+  # Envs 0, 2 should have changed.
+  assert torch.all((result[0] >= 10.0 - 1e-3) & (result[0] <= 20.0 + 1e-3))
+  assert torch.all((result[2] >= 10.0 - 1e-3) & (result[2] <= 20.0 + 1e-3))
+  # Envs 1, 3 should be unchanged.
+  assert torch.allclose(result[1], original_fovy[1])
+  assert torch.allclose(result[3], original_fovy[3])
+
+
+# geom_size DR tests.
+
+GEOM_SIZE_XML = """
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="box_geom" type="box" size="0.1 0.2 0.3" mass="1.0"/>
+      <geom name="sphere_geom" type="sphere" size="0.15" mass="0.5"/>
+      <geom name="capsule_geom" type="capsule" size="0.05 0.2" mass="0.3"/>
+      <geom name="cylinder_geom" type="cylinder" size="0.08 0.15" mass="0.4"/>
+      <geom name="ellipsoid_geom" type="ellipsoid" size="0.1 0.2 0.05"
+        mass="0.2"/>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+
+def _make_geom_size_env(device, num_envs=NUM_ENVS):
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(GEOM_SIZE_XML))
+  scene_cfg = SceneCfg(num_envs=num_envs, entities={"robot": entity_cfg})
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim = Simulation(num_envs=num_envs, cfg=SimulationCfg(), model=model, device=device)
+  scene.initialize(model, sim.model, sim.data)
+  sim.expand_model_fields(("geom_size", "geom_rbound", "geom_aabb"))
+  return Env(scene, sim, device)
+
+
+@pytest.fixture(scope="module")
+def geom_size_env(device):
+  return _make_geom_size_env(device)
+
+
+def _expected_rbound(geom_type, s0, s1, s2):
+  """Reference rbound computation matching MuJoCo GetRBound."""
+  if geom_type == "sphere":
+    return s0
+  elif geom_type == "capsule":
+    return s0 + s1
+  elif geom_type == "cylinder":
+    return math.sqrt(s0**2 + s1**2)
+  elif geom_type == "ellipsoid":
+    return max(s0, s1, s2)
+  elif geom_type == "box":
+    return math.sqrt(s0**2 + s1**2 + s2**2)
+  raise ValueError(geom_type)
+
+
+def _expected_aabb_half(geom_type, s0, s1, s2):
+  """Reference aabb half-size computation matching MuJoCo ComputeAABB."""
+  if geom_type == "sphere":
+    return (s0, s0, s0)
+  elif geom_type == "capsule":
+    return (s0, s0, s0 + s1)
+  elif geom_type == "cylinder":
+    return (s0, s0, s1)
+  elif geom_type == "ellipsoid":
+    return (s0, s1, s2)
+  elif geom_type == "box":
+    return (s0, s1, s2)
+  raise ValueError(geom_type)
+
+
+def test_geom_size_scale_updates_bounds(geom_size_env):
+  """Scaling geom_size updates rbound and aabb consistently."""
+  torch.manual_seed(42)
+  env = geom_size_env
+  robot = env.scene["robot"]
+  geom_cfg = SceneEntityCfg("robot", geom_names=(".*",))
+  geom_cfg.resolve(env.scene)
+
+  dr.geom_size(
+    env,
+    env_ids=None,
+    ranges=(0.8, 1.5),
+    operation="scale",
+    asset_cfg=geom_cfg,
+  )
+
+  geom_ids = robot.indexing.geom_ids[geom_cfg.geom_ids]
+  size = env.sim.model.geom_size[:, geom_ids]  # (E, G, 3)
+  rbound = env.sim.model.geom_rbound[:, geom_ids]  # (E, G)
+  aabb = env.sim.model.geom_aabb[:, geom_ids]  # (E, G, 2, 3)
+
+  geom_names = list(robot.geom_names)
+  type_names = {
+    "box_geom": "box",
+    "sphere_geom": "sphere",
+    "capsule_geom": "capsule",
+    "cylinder_geom": "cylinder",
+    "ellipsoid_geom": "ellipsoid",
+  }
+
+  for g_local, gname in enumerate(geom_names):
+    tname = type_names[gname]
+    for e in range(env.num_envs):
+      s0 = size[e, g_local, 0].item()
+      s1 = size[e, g_local, 1].item()
+      s2 = size[e, g_local, 2].item()
+
+      expected_rb = _expected_rbound(tname, s0, s1, s2)
+      actual_rb = rbound[e, g_local].item()
+      assert abs(actual_rb - expected_rb) < 1e-5, (
+        f"{gname} env {e}: rbound {actual_rb} != {expected_rb}"
+      )
+
+      ex, ey, ez = _expected_aabb_half(tname, s0, s1, s2)
+      actual_half = aabb[e, g_local, 1]  # half-size is index 1
+      assert abs(actual_half[0].item() - ex) < 1e-5
+      assert abs(actual_half[1].item() - ey) < 1e-5
+      assert abs(actual_half[2].item() - ez) < 1e-5
+
+      # Center should be zero for all primitives.
+      center = aabb[e, g_local, 0]
+      assert torch.allclose(center, torch.zeros(3, device=env.device), atol=1e-6)
+
+
+def test_geom_size_no_accumulation(device):
+  """Repeated scale operations don't accumulate."""
+  env = _make_geom_size_env(device, num_envs=2)
+  robot = env.scene["robot"]
+  geom_cfg = SceneEntityCfg("robot", geom_names=("box_geom",))
+  geom_cfg.resolve(env.scene)
+  geom_ids = robot.indexing.geom_ids[geom_cfg.geom_ids]
+
+  default_size = env.sim.get_default_field("geom_size")[geom_ids].clone()
+
+  for _ in range(3):
+    dr.geom_size(
+      env,
+      env_ids=None,
+      ranges=(2.0, 2.0),
+      operation="scale",
+      asset_cfg=geom_cfg,
+    )
+
+  result = env.sim.model.geom_size[0, geom_ids]
+  expected = default_size * 2.0
+  assert torch.allclose(result, expected, atol=1e-5)
+
+
+def test_geom_size_separate_axes_dont_clobber(device):
+  """Events targeting different axes of the same geom compose, not clobber."""
+  env = _make_geom_size_env(device, num_envs=2)
+  robot = env.scene["robot"]
+  geom_cfg = SceneEntityCfg("robot", geom_names=("box_geom",))
+  geom_cfg.resolve(env.scene)
+  geom_ids = robot.indexing.geom_ids[geom_cfg.geom_ids]
+
+  default_size = env.sim.get_default_field("geom_size")[geom_ids].clone()
+
+  # Scale axis 0 by 0.1, then axis 1 by 3.0 in a separate event.
+  dr.geom_size(
+    env,
+    env_ids=None,
+    ranges=(0.1, 0.1),
+    operation="scale",
+    axes=[0],
+    asset_cfg=geom_cfg,
+  )
+  dr.geom_size(
+    env,
+    env_ids=None,
+    ranges=(3.0, 3.0),
+    operation="scale",
+    axes=[1],
+    asset_cfg=geom_cfg,
+  )
+
+  result = env.sim.model.geom_size[0, geom_ids]
+  expected = default_size.clone()
+  expected[..., 0] *= 0.1
+  expected[..., 1] *= 3.0
+  assert torch.allclose(result, expected, atol=1e-5)
+
+
+def test_geom_size_partial_env_ids(device):
+  """Only specified envs are updated."""
+  env = _make_geom_size_env(device, num_envs=4)
+  robot = env.scene["robot"]
+  geom_cfg = SceneEntityCfg("robot", geom_names=("sphere_geom",))
+  geom_cfg.resolve(env.scene)
+  geom_ids = robot.indexing.geom_ids[geom_cfg.geom_ids]
+
+  original_rbound = env.sim.model.geom_rbound[:, geom_ids].clone()
+
+  dr.geom_size(
+    env,
+    env_ids=torch.tensor([0, 2], device=device),
+    ranges=(2.0, 2.0),
+    operation="scale",
+    asset_cfg=geom_cfg,
+  )
+
+  rbound = env.sim.model.geom_rbound[:, geom_ids]
+  # Envs 0, 2 should have changed.
+  assert not torch.allclose(rbound[0], original_rbound[0])
+  assert not torch.allclose(rbound[2], original_rbound[2])
+  # Envs 1, 3 should be unchanged.
+  assert torch.allclose(rbound[1], original_rbound[1])
+  assert torch.allclose(rbound[3], original_rbound[3])
+
+
+def test_geom_size_raises_on_unsupported_type(device):
+  """dr.geom_size raises ValueError when a non-primitive geom type is selected."""
+  PLANE_XML = """
+<mujoco>
+  <worldbody>
+    <geom name="floor" type="plane" size="5 5 0.1"/>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="box_geom" type="box" size="0.1 0.1 0.1" mass="1.0"/>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(PLANE_XML))
+  scene_cfg = SceneCfg(num_envs=2, entities={"robot": entity_cfg})
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim = Simulation(num_envs=2, cfg=SimulationCfg(), model=model, device=device)
+  scene.initialize(model, sim.model, sim.data)
+  sim.expand_model_fields(("geom_size", "geom_rbound", "geom_aabb"))
+  env = Env(scene, sim, device)
+
+  plane_cfg = SceneEntityCfg("robot", geom_names=("floor",))
+  plane_cfg.resolve(env.scene)
+
+  with pytest.raises(ValueError, match="unsupported types"):
+    dr.geom_size(env, env_ids=None, ranges=(1.0, 2.0), asset_cfg=plane_cfg)
+
+
+# Tendon DR tests.
+
+TENDON_XML = """
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="base_geom" type="box" size="0.1 0.1 0.1" mass="1.0"/>
+      <site name="anchor" pos="0 0 0.1"/>
+      <body name="child" pos="0.3 0 0">
+        <joint name="hinge1" type="hinge" axis="0 0 1"/>
+        <geom name="child_geom" type="sphere" size="0.05" mass="0.2"/>
+        <site name="hook" pos="0 0 -0.05"/>
+      </body>
+    </body>
+  </worldbody>
+  <tendon>
+    <spatial name="wire" limited="true" range="0 0.5" width="0.003"
+      damping="2.0" stiffness="10.0" frictionloss="0.5" armature="0.1">
+      <site site="anchor"/>
+      <site site="hook"/>
+    </spatial>
+  </tendon>
+</mujoco>
+"""
+
+
+def _make_tendon_env(device, num_envs=NUM_ENVS):
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(TENDON_XML))
+  scene_cfg = SceneCfg(num_envs=num_envs, entities={"robot": entity_cfg})
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim = Simulation(num_envs=num_envs, cfg=SimulationCfg(), model=model, device=device)
+  scene.initialize(model, sim.model, sim.data)
+  sim.expand_model_fields(
+    (
+      "tendon_damping",
+      "tendon_stiffness",
+      "tendon_frictionloss",
+      "tendon_armature",
+    )
+  )
+
+  return Env(scene, sim, device)
+
+
+@pytest.fixture(scope="module")
+def tendon_env(device):
+  return _make_tendon_env(device)
+
+
+@pytest.mark.parametrize(
+  "dr_func, field",
+  [
+    (dr.tendon_damping, "tendon_damping"),
+    (dr.tendon_stiffness, "tendon_stiffness"),
+    (dr.tendon_friction, "tendon_frictionloss"),
+    (dr.tendon_armature, "tendon_armature"),
+  ],
+)
+def test_tendon_field_scale(tendon_env, dr_func, field):
+  """Scale operation on tendon fields: result = default * sample."""
+  torch.manual_seed(42)
+  env = tendon_env
+  robot = env.scene["robot"]
+  tendon_cfg = SceneEntityCfg("robot", tendon_names=(".*",))
+  tendon_cfg.resolve(env.scene)
+  tendon_ids = robot.indexing.tendon_ids[tendon_cfg.tendon_ids]
+
+  default_val = env.sim.get_default_field(field)[tendon_ids].clone()
+
+  dr_func(
+    env,
+    env_ids=None,
+    ranges=(0.5, 2.0),
+    operation="scale",
+    asset_cfg=tendon_cfg,
+  )
+
+  result = getattr(env.sim.model, field)[:, tendon_ids]
+  lo = default_val * 0.5 - 1e-5
+  hi = default_val * 2.0 + 1e-5
+  assert torch.all((result >= lo) & (result <= hi))
+
+
+def test_tendon_armature_no_accumulation(device):
+  """Repeated scale does not accumulate."""
+  env = _make_tendon_env(device, num_envs=2)
+  robot = env.scene["robot"]
+  tendon_cfg = SceneEntityCfg("robot", tendon_names=(".*",))
+  tendon_cfg.resolve(env.scene)
+  tendon_ids = robot.indexing.tendon_ids[tendon_cfg.tendon_ids]
+
+  default_val = env.sim.get_default_field("tendon_armature")[tendon_ids]
+
+  for _ in range(3):
+    dr.tendon_armature(
+      env,
+      env_ids=None,
+      ranges=(2.0, 2.0),
+      operation="scale",
+      asset_cfg=tendon_cfg,
+    )
+
+  result = env.sim.model.tendon_armature[0, tendon_ids]
+  assert torch.allclose(result, default_val * 2.0, atol=1e-5)
+
+
+# Extensible Operation / Distribution types.
+
+
+def test_operation_instance_abs(device):
+  """Passing an Operation instance works identically to the string."""
+  from mjlab.envs.mdp.dr._types import abs as abs_op
+
+  torch.manual_seed(42)
+  env1 = create_test_env(device)
+  robot = env1.scene["robot"]
+
+  dr.geom_friction(
+    env1,
+    env_ids=None,
+    ranges=(0.3, 1.2),
+    operation="abs",
+    asset_cfg=SceneEntityCfg("robot", geom_names=(".*",)),
+    axes=[0],
+  )
+  result_str = env1.sim.model.geom_friction[:, robot.indexing.geom_ids, 0].clone()
+
+  torch.manual_seed(42)
+  env2 = create_test_env(device)
+
+  dr.geom_friction(
+    env2,
+    env_ids=None,
+    ranges=(0.3, 1.2),
+    operation=abs_op,
+    asset_cfg=SceneEntityCfg("robot", geom_names=(".*",)),
+    axes=[0],
+  )
+  result_inst = env2.sim.model.geom_friction[:, robot.indexing.geom_ids, 0]
+
+  assert torch.allclose(result_str, result_inst)
+
+
+def test_distribution_instance_uniform(device):
+  """Passing a Distribution instance works identically to the string."""
+  from mjlab.envs.mdp.dr._types import uniform as uniform_dist
+
+  torch.manual_seed(42)
+  env1 = create_test_env(device)
+  robot = env1.scene["robot"]
+
+  dr.geom_friction(
+    env1,
+    env_ids=None,
+    ranges=(0.3, 1.2),
+    distribution="uniform",
+    operation="abs",
+    asset_cfg=SceneEntityCfg("robot", geom_names=(".*",)),
+    axes=[0],
+  )
+  result_str = env1.sim.model.geom_friction[:, robot.indexing.geom_ids, 0].clone()
+
+  torch.manual_seed(42)
+  env2 = create_test_env(device)
+
+  dr.geom_friction(
+    env2,
+    env_ids=None,
+    ranges=(0.3, 1.2),
+    distribution=uniform_dist,
+    operation="abs",
+    asset_cfg=SceneEntityCfg("robot", geom_names=(".*",)),
+    axes=[0],
+  )
+  result_inst = env2.sim.model.geom_friction[:, robot.indexing.geom_ids, 0]
+
+  assert torch.allclose(result_str, result_inst)
+
+
+def test_custom_operation(env):
+  """A user-defined Operation works end-to-end."""
+  from mjlab.envs.mdp.dr._types import Operation
+
+  clamp_op = Operation(
+    name="clamp",
+    initialize=torch.Tensor.clone,
+    combine=lambda _base, random: torch.clamp(random, min=0.4, max=0.9),
+    uses_defaults=False,
+  )
+
+  torch.manual_seed(42)
+  robot = env.scene["robot"]
+
+  dr.geom_friction(
+    env,
+    env_ids=None,
+    ranges=(0.1, 1.5),
+    operation=clamp_op,
+    asset_cfg=SceneEntityCfg("robot", geom_names=(".*",)),
+    axes=[0],
+  )
+
+  friction = env.sim.model.geom_friction[:, robot.indexing.geom_ids, 0]
+  assert torch.all((friction >= 0.4 - 1e-5) & (friction <= 0.9 + 1e-5))
+
+
+def test_custom_distribution(env):
+  """A user-defined Distribution works end-to-end."""
+  from mjlab.envs.mdp.dr._types import Distribution
+
+  # Distribution that always returns the midpoint.
+  midpoint_dist = Distribution(
+    name="midpoint",
+    sample=lambda lo, hi, shape, _device: ((lo + hi) / 2).expand(shape),
+  )
+
+  robot = env.scene["robot"]
+
+  dr.geom_friction(
+    env,
+    env_ids=None,
+    ranges=(0.2, 0.8),
+    distribution=midpoint_dist,
+    operation="abs",
+    asset_cfg=SceneEntityCfg("robot", geom_names=(".*",)),
+    axes=[0],
+  )
+
+  friction = env.sim.model.geom_friction[:, robot.indexing.geom_ids, 0]
+  assert torch.allclose(friction, torch.tensor(0.5, device=env.device), atol=1e-5)
+
+
+def test_resolve_unknown_operation_raises(device):
+  """Unknown operation string raises ValueError."""
+  from mjlab.envs.mdp.dr._types import resolve_operation
+
+  with pytest.raises(ValueError, match="Unknown operation"):
+    resolve_operation("nonexistent")
+
+
+def test_resolve_unknown_distribution_raises(device):
+  """Unknown distribution string raises ValueError."""
+  from mjlab.envs.mdp.dr._types import resolve_distribution
+
+  with pytest.raises(ValueError, match="Unknown distribution"):
+    resolve_distribution("nonexistent")
+
+
+# mat_rgba tests.
+
+MAT_XML = """
+<mujoco>
+  <asset>
+    <material name="test_mat" rgba="1 1 1 1" emission="0.1"
+      specular="0.2" shininess="0.3" texrepeat="1 2"/>
+  </asset>
+  <worldbody>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="base_geom" type="box" size="0.1 0.1 0.1" mass="1.0"
+        material="test_mat"/>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+
+def _make_mat_env(device, num_envs=NUM_ENVS):
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(MAT_XML))
+  scene_cfg = SceneCfg(num_envs=num_envs, entities={"robot": entity_cfg})
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim = Simulation(num_envs=num_envs, cfg=SimulationCfg(), model=model, device=device)
+  scene.initialize(model, sim.model, sim.data)
+  sim.expand_model_fields(
+    ("mat_rgba", "mat_emission", "mat_specular", "mat_shininess", "mat_texrepeat")
+  )
+  return Env(scene, sim, device)
+
+
+@pytest.fixture(scope="module")
+def mat_env(device):
+  return _make_mat_env(device)
+
+
+def test_mat_rgba_abs(mat_env):
+  """Values within range, diversity across envs."""
+  torch.manual_seed(42)
+  env = mat_env
+
+  dr.mat_rgba(
+    env,
+    env_ids=None,
+    ranges=(0.2, 0.8),
+    asset_cfg=SceneEntityCfg("robot", material_names=("test_mat",)),
+    operation="abs",
+  )
+
+  mat_id = mujoco.mj_name2id(
+    env.sim.mj_model, mujoco.mjtObj.mjOBJ_MATERIAL, "robot/test_mat"
+  )
+  rgba = env.sim.model.mat_rgba[:, mat_id, :]
+  assert torch.all((rgba >= 0.2 - 1e-5) & (rgba <= 0.8 + 1e-5))
+  assert len(torch.unique(rgba[:, 0])) >= 2
+
+
+@pytest.mark.parametrize(
+  ("func_name", "field", "ranges"),
+  [
+    ("mat_emission", "mat_emission", (0.1, 0.7)),
+    ("mat_specular", "mat_specular", (0.0, 1.0)),
+    ("mat_shininess", "mat_shininess", (0.2, 0.9)),
+  ],
+)
+def test_scalar_material_fields_abs(mat_env, func_name, field, ranges):
+  """Scalar material fields randomize per selected material."""
+  torch.manual_seed(42)
+  env = mat_env
+  func = getattr(dr, func_name)
+
+  func(
+    env,
+    env_ids=None,
+    ranges=ranges,
+    asset_cfg=SceneEntityCfg("robot", material_names=("test_mat",)),
+    operation="abs",
+  )
+
+  mat_id = mujoco.mj_name2id(
+    env.sim.mj_model, mujoco.mjtObj.mjOBJ_MATERIAL, "robot/test_mat"
+  )
+  values = getattr(env.sim.model, field)[:, mat_id]
+  lower, upper = ranges
+  assert torch.all((values >= lower - 1e-5) & (values <= upper + 1e-5))
+  assert len(torch.unique(values)) >= 2
+
+
+def test_mat_texrepeat_abs(mat_env):
+  """Texture repeat randomizes S/T axes for selected materials."""
+  torch.manual_seed(42)
+  env = mat_env
+
+  dr.mat_texrepeat(
+    env,
+    env_ids=None,
+    ranges={0: (1.0, 3.0), 1: (4.0, 6.0)},
+    asset_cfg=SceneEntityCfg("robot", material_names=("test_mat",)),
+    operation="abs",
+  )
+
+  mat_id = mujoco.mj_name2id(
+    env.sim.mj_model, mujoco.mjtObj.mjOBJ_MATERIAL, "robot/test_mat"
+  )
+  texrepeat = env.sim.model.mat_texrepeat[:, mat_id, :]
+  assert torch.all((texrepeat[:, 0] >= 1.0 - 1e-5) & (texrepeat[:, 0] <= 3.0 + 1e-5))
+  assert torch.all((texrepeat[:, 1] >= 4.0 - 1e-5) & (texrepeat[:, 1] <= 6.0 + 1e-5))
+  assert len(torch.unique(texrepeat[:, 0])) >= 2
+
+
+@pytest.mark.parametrize(
+  ("func_name", "field"),
+  [
+    ("mat_emission", "mat_emission"),
+    ("mat_specular", "mat_specular"),
+    ("mat_shininess", "mat_shininess"),
+  ],
+)
+def test_scalar_material_fields_scale_use_defaults(mat_env, func_name, field):
+  """Scale operation uses compiled defaults for scalar material fields."""
+  env = mat_env
+  func = getattr(dr, func_name)
+
+  func(
+    env,
+    env_ids=None,
+    ranges=(2.0, 2.0),
+    asset_cfg=SceneEntityCfg("robot", material_names=("test_mat",)),
+    operation="scale",
+  )
+
+  mat_id = mujoco.mj_name2id(
+    env.sim.mj_model, mujoco.mjtObj.mjOBJ_MATERIAL, "robot/test_mat"
+  )
+  expected = env.sim.get_default_field(field)[mat_id] * 2.0
+  values = getattr(env.sim.model, field)[:, mat_id]
+  assert torch.allclose(values, expected.expand_as(values))
+
+
+def test_mat_texrepeat_scale_uses_defaults(mat_env):
+  """Scale operation uses compiled defaults and both S/T axes by default."""
+  env = mat_env
+
+  dr.mat_texrepeat(
+    env,
+    env_ids=None,
+    ranges=(2.0, 2.0),
+    asset_cfg=SceneEntityCfg("robot", material_names=("test_mat",)),
+    operation="scale",
+  )
+
+  mat_id = mujoco.mj_name2id(
+    env.sim.mj_model, mujoco.mjtObj.mjOBJ_MATERIAL, "robot/test_mat"
+  )
+  expected = env.sim.get_default_field("mat_texrepeat")[mat_id] * 2.0
+  texrepeat = env.sim.model.mat_texrepeat[:, mat_id, :]
+  assert torch.allclose(texrepeat, expected.expand_as(texrepeat))
+
+
+def test_mat_rgba_invalid_name(mat_env):
+  """ValueError for unknown material name."""
+  env = mat_env
+
+  with pytest.raises(ValueError, match="nonexistent_material"):
+    cfg = SceneEntityCfg("robot", material_names=("nonexistent_material",))
+    cfg.resolve(env.scene)
+    dr.mat_rgba(
+      env,
+      env_ids=None,
+      ranges=(0.2, 0.8),
+      asset_cfg=cfg,
+    )
+
+
+# geom_matid DR tests.
+
+GEOM_MATID_XML = """
+<mujoco>
+  <asset>
+    <material name="mat_a" rgba="1 0 0 1"/>
+    <material name="mat_b" rgba="0 1 0 1"/>
+    <material name="mat_c" rgba="0 0 1 1"/>
+  </asset>
+  <worldbody>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="geom1" type="box" size="0.1 0.1 0.1" mass="1.0" material="mat_a"/>
+      <geom name="geom2" type="sphere" size="0.05" mass="0.3" material="mat_b"/>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+
+def _make_matid_env(device, num_envs=NUM_ENVS):
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(GEOM_MATID_XML))
+  scene_cfg = SceneCfg(num_envs=num_envs, entities={"robot": entity_cfg})
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim = Simulation(num_envs=num_envs, cfg=SimulationCfg(), model=model, device=device)
+  scene.initialize(model, sim.model, sim.data)
+  sim.expand_model_fields(("geom_matid",))
+  return Env(scene, sim, device)
+
+
+@pytest.fixture(scope="module")
+def matid_env(device):
+  return _make_matid_env(device)
+
+
+def test_geom_matid_draws_from_pool(matid_env):
+  """Assigned matids come from the pool and actually change from the defaults."""
+  torch.manual_seed(42)
+  env = matid_env
+  robot = env.scene["robot"]
+  asset_cfg = SceneEntityCfg("robot", geom_names=(".*",), material_names=(".*",))
+  asset_cfg.resolve(env.scene)
+
+  geom_ids = robot.indexing.geom_ids[asset_cfg.geom_ids]
+  mat_ids = robot.indexing.mat_ids[asset_cfg.material_ids]
+  original = env.sim.model.geom_matid[:, geom_ids].clone()
+
+  dr.geom_matid(env, env_ids=None, asset_cfg=asset_cfg)
+
+  assigned = env.sim.model.geom_matid[:, geom_ids]
+  # Every assignment is a valid member of the selected pool.
+  assert torch.all(torch.isin(assigned, mat_ids))
+  # Randomization is not a no-op: values differ from the baked defaults, and at
+  # least one geom draws a material it did not start with (proving the full pool
+  # is sampled, not just the compile-time defaults).
+  assert not torch.equal(assigned, original)
+  assert torch.isin(assigned, torch.unique(original), invert=True).any()
+
+
+def test_geom_matid_partial_env_ids(matid_env):
+  """Randomizing subset of envs leaves others unchanged."""
+  torch.manual_seed(42)
+  env = matid_env
+  robot = env.scene["robot"]
+  asset_cfg = SceneEntityCfg("robot", geom_names=(".*",), material_names=(".*",))
+  asset_cfg.resolve(env.scene)
+  geom_ids = robot.indexing.geom_ids[asset_cfg.geom_ids]
+
+  original = env.sim.model.geom_matid[:, geom_ids].clone()
+
+  dr.geom_matid(
+    env, env_ids=torch.tensor([0, 2], device=env.device), asset_cfg=asset_cfg
+  )
+
+  result = env.sim.model.geom_matid[:, geom_ids]
+  assert torch.all(result[1] == original[1])
+  assert torch.all(result[3] == original[3])
+
+
+def test_geom_matid_invalid_material_name(matid_env):
+  """Unknown material name is rejected during config resolution."""
+  env = matid_env
+
+  with pytest.raises(ValueError, match="nonexistent_material"):
+    cfg = SceneEntityCfg(
+      "robot", geom_names=(".*",), material_names=("nonexistent_material",)
+    )
+    cfg.resolve(env.scene)
+    dr.geom_matid(env, env_ids=None, asset_cfg=cfg)
+
+
+def test_geom_matid_empty_material_selection(matid_env):
+  """geom_matid raises when the resolved material pool is empty."""
+  env = matid_env
+  cfg = SceneEntityCfg("robot", geom_names=(".*",), material_names=())
+  cfg.resolve(env.scene)
+
+  with pytest.raises(ValueError, match="No materials selected"):
+    dr.geom_matid(env, env_ids=None, asset_cfg=cfg)
+
+
+def test_geom_matid_shared_random(matid_env):
+  """All geoms within same env get same material, envs differ."""
+  torch.manual_seed(42)
+  env = matid_env
+  robot = env.scene["robot"]
+  asset_cfg = SceneEntityCfg("robot", geom_names=(".*",), material_names=(".*",))
+  asset_cfg.resolve(env.scene)
+  geom_ids = robot.indexing.geom_ids[asset_cfg.geom_ids]
+
+  dr.geom_matid(env, env_ids=None, asset_cfg=asset_cfg, shared_random=True)
+
+  assigned = env.sim.model.geom_matid[:, geom_ids]
+  for env_idx in range(env.num_envs):
+    env_matids = assigned[env_idx]
+    assert torch.all(env_matids == env_matids[0])
+
+  assert len(torch.unique(assigned[:, 0])) > 1
+
+
+# mat_texid DR tests.
+
+MAT_TEXID_XML = """
+<mujoco>
+  <asset>
+    <texture name="tex_a" type="2d" builtin="flat" rgb1="1 0 0" width="4" height="4"/>
+    <texture name="tex_b" type="2d" builtin="flat" rgb1="0 1 0" width="4" height="4"/>
+    <texture name="tex_c" type="2d" builtin="flat" rgb1="0 0 1" width="4" height="4"/>
+    <texture name="tex_d" type="2d" builtin="flat" rgb1="1 1 0" width="4" height="4"/>
+    <material name="mat_a" texture="tex_a"/>
+    <material name="mat_b" texture="tex_b"/>
+  </asset>
+  <worldbody>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="geom1" type="box" size="0.1 0.1 0.1" mass="1.0" material="mat_a"/>
+      <geom name="geom2" type="sphere" size="0.05" mass="0.3" material="mat_b"/>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+
+def _make_texid_env(device, num_envs=NUM_ENVS):
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(MAT_TEXID_XML))
+  scene_cfg = SceneCfg(num_envs=num_envs, entities={"robot": entity_cfg})
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim = Simulation(num_envs=num_envs, cfg=SimulationCfg(), model=model, device=device)
+  scene.initialize(model, sim.model, sim.data)
+  sim.expand_model_fields(("mat_texid",))
+  return Env(scene, sim, device)
+
+
+@pytest.fixture
+def texid_env(device):
+  # Function-scoped so tests compare against pristine mat_texid defaults.
+  return _make_texid_env(device)
+
+
+def test_mat_texid_draws_from_pool(texid_env):
+  """Assigned texids come from the pool and actually change from the defaults."""
+  torch.manual_seed(42)
+  env = texid_env
+  robot = env.scene["robot"]
+  asset_cfg = SceneEntityCfg("robot", material_names=(".*",), texture_names=(".*",))
+  asset_cfg.resolve(env.scene)
+
+  mat_ids = robot.indexing.mat_ids[asset_cfg.material_ids]
+  tex_ids = robot.indexing.tex_ids[asset_cfg.texture_ids]
+  role = mujoco.mjtTextureRole.mjTEXROLE_RGB.value
+  original = env.sim.model.mat_texid[:, mat_ids, role].clone()
+
+  dr.mat_texid(env, env_ids=None, asset_cfg=asset_cfg)
+
+  assigned = env.sim.model.mat_texid[:, mat_ids, role]
+  assert torch.all(torch.isin(assigned, tex_ids))
+  assert not torch.equal(assigned, original)
+  assert torch.isin(assigned, torch.unique(original), invert=True).any()
+
+
+def test_mat_texid_respects_texture_subset(texid_env):
+  """Textures outside the selection are never sampled."""
+  torch.manual_seed(42)
+  env = texid_env
+  robot = env.scene["robot"]
+  # The pool excludes tex_a and tex_b, which are the two materials' defaults.
+  asset_cfg = SceneEntityCfg(
+    "robot", material_names=(".*",), texture_names=("tex_c", "tex_d")
+  )
+  asset_cfg.resolve(env.scene)
+
+  mat_ids = robot.indexing.mat_ids[asset_cfg.material_ids]
+  tex_ids = robot.indexing.tex_ids[asset_cfg.texture_ids]
+  role = mujoco.mjtTextureRole.mjTEXROLE_RGB.value
+  excluded = torch.unique(env.sim.model.mat_texid[:, mat_ids, role])
+
+  dr.mat_texid(env, env_ids=None, asset_cfg=asset_cfg)
+
+  assigned = env.sim.model.mat_texid[:, mat_ids, role]
+  assert torch.all(torch.isin(assigned, tex_ids))
+  assert not torch.isin(assigned, excluded).any()
+  assert len(torch.unique(assigned)) >= 2
+
+
+def test_mat_texid_partial_env_ids(texid_env):
+  """Randomizing subset of envs leaves others unchanged."""
+  torch.manual_seed(42)
+  env = texid_env
+  robot = env.scene["robot"]
+  asset_cfg = SceneEntityCfg(
+    "robot", material_names=(".*",), texture_names=("tex_c", "tex_d")
+  )
+  asset_cfg.resolve(env.scene)
+  mat_ids = robot.indexing.mat_ids[asset_cfg.material_ids]
+  tex_ids = robot.indexing.tex_ids[asset_cfg.texture_ids]
+  role = mujoco.mjtTextureRole.mjTEXROLE_RGB.value
+
+  original = env.sim.model.mat_texid[:, mat_ids, role].clone()
+
+  dr.mat_texid(
+    env, env_ids=torch.tensor([0, 2], device=env.device), asset_cfg=asset_cfg
+  )
+
+  result = env.sim.model.mat_texid[:, mat_ids, role]
+  # Envs 0, 2 changed, the pool excludes their defaults.
+  assert torch.all(torch.isin(result[0], tex_ids))
+  assert torch.all(torch.isin(result[2], tex_ids))
+  assert not torch.equal(result[0], original[0])
+  assert not torch.equal(result[2], original[2])
+  # Envs 1, 3 unchanged.
+  assert torch.all(result[1] == original[1])
+  assert torch.all(result[3] == original[3])
+
+
+def test_mat_texid_invalid_texture_name(texid_env):
+  """Unknown texture name is rejected during config resolution."""
+  env = texid_env
+
+  with pytest.raises(ValueError, match="nonexistent_texture"):
+    cfg = SceneEntityCfg(
+      "robot", material_names=(".*",), texture_names=("nonexistent_texture",)
+    )
+    cfg.resolve(env.scene)
+    dr.mat_texid(env, env_ids=None, asset_cfg=cfg)
+
+
+def test_mat_texid_empty_texture_selection(texid_env):
+  """mat_texid raises when the resolved texture pool is empty."""
+  env = texid_env
+  cfg = SceneEntityCfg("robot", material_names=(".*",), texture_names=())
+  cfg.resolve(env.scene)
+
+  with pytest.raises(ValueError, match="No textures selected"):
+    dr.mat_texid(env, env_ids=None, asset_cfg=cfg)
+
+
+def test_mat_texid_shared_random(texid_env):
+  """All materials within same env get same texture, envs differ."""
+  torch.manual_seed(42)
+  env = texid_env
+  robot = env.scene["robot"]
+  asset_cfg = SceneEntityCfg("robot", material_names=(".*",), texture_names=(".*",))
+  asset_cfg.resolve(env.scene)
+  mat_ids = robot.indexing.mat_ids[asset_cfg.material_ids]
+  role = mujoco.mjtTextureRole.mjTEXROLE_RGB.value
+
+  dr.mat_texid(env, env_ids=None, asset_cfg=asset_cfg, shared_random=True)
+
+  assigned = env.sim.model.mat_texid[:, mat_ids, role]
+  for env_idx in range(env.num_envs):
+    env_texids = assigned[env_idx]
+    assert torch.all(env_texids == env_texids[0])
+
+  assert len(torch.unique(assigned[:, 0])) > 1
+
+
+# pair_friction tests.
+
+PAIR_XML = """
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="base_geom" type="box" size="0.1 0.1 0.1" mass="1.0"/>
+      <body name="foot" pos="0 0 -0.15">
+        <geom name="foot_geom" type="box" size="0.05 0.05 0.02" mass="0.1"/>
+      </body>
+    </body>
+    <geom name="floor" type="plane" size="2 2 0.1"/>
+  </worldbody>
+  <contact>
+    <pair name="base_floor" geom1="base_geom" geom2="floor"
+          friction="0.5 0.5 0.005 0.0001 0.0001"/>
+    <pair name="foot_floor" geom1="foot_geom" geom2="floor"
+          friction="0.3 0.3 0.003 0.0002 0.0002"/>
+  </contact>
+</mujoco>
+"""
+
+
+@pytest.fixture(scope="module")
+def pair_env(device):
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(PAIR_XML))
+  scene_cfg = SceneCfg(num_envs=NUM_ENVS, entities={"robot": entity_cfg})
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim = Simulation(num_envs=NUM_ENVS, cfg=SimulationCfg(), model=model, device=device)
+  scene.initialize(model, sim.model, sim.data)
+  sim.expand_model_fields(("pair_friction",))
+  return Env(scene, sim, device)
+
+
+def test_pair_friction_abs(pair_env):
+  """Values set directly within range, diverse across envs."""
+  torch.manual_seed(42)
+  env = pair_env
+  robot = env.scene["robot"]
+
+  dr.pair_friction(env, env_ids=None, ranges=(0.4, 1.5), operation="abs")
+
+  friction = env.sim.model.pair_friction[:, robot.indexing.pair_ids, 0]
+  assert torch.all((friction >= 0.4) & (friction <= 1.5))
+  assert len(torch.unique(friction)) >= 2
+
+
+def test_pair_friction_scale(pair_env):
+  """Values = default * sample; no accumulation after 3 calls."""
+  env = pair_env
+  robot = env.scene["robot"]
+  pair_idx = robot.indexing.pair_ids[0]
+  default_val = env.sim.get_default_field("pair_friction")[pair_idx, 0].item()
+
+  for _ in range(3):
+    dr.pair_friction(
+      env,
+      env_ids=None,
+      ranges=(2.0, 2.0),
+      operation="scale",
+      asset_cfg=SceneEntityCfg("robot", pair_ids=[0]),
+      axes=[0],
+    )
+
+  result = env.sim.model.pair_friction[:, pair_idx, 0]
+  assert torch.allclose(result, torch.full_like(result, default_val * 2.0), atol=1e-5)
+
+
+def test_pair_friction_add(pair_env):
+  """Values = default + sample; no accumulation after 3 calls."""
+  env = pair_env
+  robot = env.scene["robot"]
+  pair_idx = robot.indexing.pair_ids[0]
+  default_val = env.sim.get_default_field("pair_friction")[pair_idx, 0].item()
+
+  for _ in range(3):
+    dr.pair_friction(
+      env,
+      env_ids=None,
+      ranges=(0.1, 0.1),
+      operation="add",
+      asset_cfg=SceneEntityCfg("robot", pair_ids=[0]),
+      axes=[0],
+    )
+
+  result = env.sim.model.pair_friction[:, pair_idx, 0]
+  assert torch.allclose(result, torch.full_like(result, default_val + 0.1), atol=1e-5)
+
+
+def test_pair_friction_axes_selectivity(pair_env):
+  """Only the targeted axis changes; others stay at their original values."""
+  torch.manual_seed(7)
+  env = pair_env
+  robot = env.scene["robot"]
+
+  before = env.sim.model.pair_friction.clone()
+
+  dr.pair_friction(env, env_ids=None, ranges=(0.8, 1.2), operation="abs", axes=[0])
+
+  after = env.sim.model.pair_friction
+  pair_ids = robot.indexing.pair_ids
+  # Axis 0 changed.
+  assert not torch.allclose(after[:, pair_ids, 0], before[:, pair_ids, 0])
+  # Axes 1-4 unchanged.
+  for ax in range(1, 5):
+    assert torch.allclose(after[:, pair_ids, ax], before[:, pair_ids, ax])
+
+
+def test_pair_friction_multi_axis(pair_env):
+  """axes=[0, 1] randomizes both tangent components; axes 2-4 stay unchanged."""
+  torch.manual_seed(17)
+  env = pair_env
+  robot = env.scene["robot"]
+
+  before = env.sim.model.pair_friction.clone()
+
+  dr.pair_friction(env, env_ids=None, ranges=(0.4, 1.0), operation="abs", axes=[0, 1])
+
+  after = env.sim.model.pair_friction
+  pair_ids = robot.indexing.pair_ids
+  # Both tangent axes changed.
+  assert not torch.allclose(after[:, pair_ids, 0], before[:, pair_ids, 0])
+  assert not torch.allclose(after[:, pair_ids, 1], before[:, pair_ids, 1])
+  # Axes 2-4 unchanged.
+  for ax in range(2, 5):
+    assert torch.allclose(after[:, pair_ids, ax], before[:, pair_ids, ax])
+  # Axis 0 and axis 1 are sampled independently (not forced equal).
+  assert not torch.allclose(after[:, pair_ids, 0], after[:, pair_ids, 1])
+
+
+def test_pair_friction_partial_env_ids(pair_env):
+  """Randomizing a subset of envs leaves the others unchanged."""
+  torch.manual_seed(99)
+  env = pair_env
+  robot = env.scene["robot"]
+
+  before = env.sim.model.pair_friction.clone()
+  randomized_ids = torch.tensor([0, 1], device=env.device)
+
+  dr.pair_friction(
+    env, env_ids=randomized_ids, ranges=(2.0, 3.0), operation="abs", axes=[0]
+  )
+
+  after = env.sim.model.pair_friction
+  pair_ids = robot.indexing.pair_ids
+  unchanged_ids = torch.tensor([2, 3], device=env.device)
+  assert torch.allclose(
+    after[unchanged_ids[:, None], pair_ids[None, :], :],
+    before[unchanged_ids[:, None], pair_ids[None, :], :],
+  )
+
+
+def test_pair_friction_shared_random(pair_env):
+  """All pairs in the same env get the same value; envs differ."""
+  torch.manual_seed(5)
+  env = pair_env
+  robot = env.scene["robot"]
+
+  dr.pair_friction(
+    env, env_ids=None, ranges=(0.5, 2.0), operation="abs", axes=[0], shared_random=True
+  )
+
+  pair_ids = robot.indexing.pair_ids
+  friction = env.sim.model.pair_friction[:, pair_ids, 0]
+  # Within each env, all pairs have the same value.
+  for e in range(env.num_envs):
+    row = friction[e]
+    assert torch.allclose(row, row[0].expand_as(row), atol=1e-6)
+  # Across envs, values differ.
+  assert not torch.allclose(friction[0], friction[1])
+
+
+def test_pair_friction_by_name(pair_env):
+  """Targeting pair by name only modifies that pair."""
+  torch.manual_seed(11)
+  env = pair_env
+  robot = env.scene["robot"]
+
+  foot_cfg = SceneEntityCfg("robot", pair_names=("foot_floor",))
+  foot_cfg.resolve(env.scene)
+  base_cfg = SceneEntityCfg("robot", pair_names=("base_floor",))
+  base_cfg.resolve(env.scene)
+  foot_pair_id = robot.indexing.pair_ids[foot_cfg.pair_ids]
+  base_pair_id = robot.indexing.pair_ids[base_cfg.pair_ids]
+
+  before = env.sim.model.pair_friction.clone()
+  dr.pair_friction(
+    env, env_ids=None, ranges=(1.5, 2.5), operation="abs", asset_cfg=foot_cfg
+  )
+
+  after = env.sim.model.pair_friction
+  # foot_floor changed.
+  assert not torch.allclose(after[:, foot_pair_id, 0], before[:, foot_pair_id, 0])
+  # base_floor unchanged.
+  assert torch.allclose(after[:, base_pair_id, :], before[:, base_pair_id, :])
+
+
+def test_pair_friction_string_ranges(pair_env):
+  """Dict with pair name patterns randomizes the matched pairs correctly."""
+  torch.manual_seed(13)
+  env = pair_env
+  robot = env.scene["robot"]
+
+  dr.pair_friction(
+    env,
+    env_ids=None,
+    ranges={"base_floor": (1.0, 1.0), "foot_floor": (0.5, 0.5)},
+    operation="abs",
+    axes=[0],
+  )
+
+  base_cfg = SceneEntityCfg("robot", pair_names=("base_floor",))
+  base_cfg.resolve(env.scene)
+  foot_cfg = SceneEntityCfg("robot", pair_names=("foot_floor",))
+  foot_cfg.resolve(env.scene)
+  base_id = robot.indexing.pair_ids[base_cfg.pair_ids]
+  foot_id = robot.indexing.pair_ids[foot_cfg.pair_ids]
+  assert torch.allclose(
+    env.sim.model.pair_friction[:, base_id, 0],
+    torch.ones(env.num_envs, device=env.device),
+    atol=1e-5,
+  )
+  assert torch.allclose(
+    env.sim.model.pair_friction[:, foot_id, 0],
+    torch.full((env.num_envs,), 0.5, device=env.device),
+    atol=1e-5,
+  )
+
+
+def test_pair_friction_isotropic_tangent(pair_env):
+  """isotropic=True mirrors tangent2 = tangent1; spin and roll axes unchanged."""
+  torch.manual_seed(21)
+  env = pair_env
+  robot = env.scene["robot"]
+  pair_ids = robot.indexing.pair_ids
+
+  before = env.sim.model.pair_friction.clone()
+  dr.pair_friction(
+    env, env_ids=None, ranges=(0.4, 1.0), operation="abs", axes=[0], isotropic=True
+  )
+
+  after = env.sim.model.pair_friction
+  # Axis 0 was randomized into range.
+  assert torch.all((after[:, pair_ids, 0] >= 0.4) & (after[:, pair_ids, 0] <= 1.0))
+  # Axis 1 equals axis 0 exactly.
+  assert torch.allclose(after[:, pair_ids, 1], after[:, pair_ids, 0])
+  # Axes 2, 3, 4 untouched.
+  for ax in (2, 3, 4):
+    assert torch.allclose(after[:, pair_ids, ax], before[:, pair_ids, ax])
+
+
+def test_pair_friction_isotropic_shared(pair_env):
+  """isotropic=True + shared_random=True: all pairs same value, tangent2 == tangent1."""
+  torch.manual_seed(33)
+  env = pair_env
+  robot = env.scene["robot"]
+  pair_ids = robot.indexing.pair_ids
+
+  dr.pair_friction(
+    env,
+    env_ids=None,
+    ranges=(0.4, 1.0),
+    operation="abs",
+    axes=[0],
+    shared_random=True,
+    isotropic=True,
+  )
+
+  friction = env.sim.model.pair_friction[:, pair_ids, :]
+  # All pairs in each env share the same tangent1 value.
+  for e in range(env.num_envs):
+    assert torch.allclose(
+      friction[e, :, 0], friction[e, 0, 0].expand(len(pair_ids)), atol=1e-6
+    )
+  # Across envs, values differ.
+  assert not torch.allclose(friction[0, 0, 0], friction[1, 0, 0])
+  # tangent2 == tangent1 everywhere.
+  assert torch.allclose(friction[:, :, 1], friction[:, :, 0])
+
+
+def test_pair_friction_isotropic_roll(pair_env):
+  """isotropic=True with roll axes mirrors roll2 = roll1; tangent axes unchanged."""
+  torch.manual_seed(41)
+  env = pair_env
+  robot = env.scene["robot"]
+  pair_ids = robot.indexing.pair_ids
+
+  before = env.sim.model.pair_friction.clone()
+  dr.pair_friction(
+    env, env_ids=None, ranges=(0.001, 0.01), operation="abs", axes=[3], isotropic=True
+  )
+
+  after = env.sim.model.pair_friction
+  # Axis 3 was randomized.
+  assert not torch.allclose(after[:, pair_ids, 3], before[:, pair_ids, 3])
+  # Axis 4 equals axis 3 exactly.
+  assert torch.allclose(after[:, pair_ids, 4], after[:, pair_ids, 3])
+  # Tangent and spin axes untouched.
+  for ax in (0, 1, 2):
+    assert torch.allclose(after[:, pair_ids, ax], before[:, pair_ids, ax])
+
+
+def test_pair_friction_isotropic_roll_dict_ranges(pair_env):
+  """isotropic=True with dict-int ranges containing roll axis triggers roll2 = roll1."""
+  torch.manual_seed(53)
+  env = pair_env
+  robot = env.scene["robot"]
+  pair_ids = robot.indexing.pair_ids
+
+  before = env.sim.model.pair_friction.clone()
+  dr.pair_friction(
+    env,
+    env_ids=None,
+    ranges={3: (0.001, 0.01)},
+    operation="abs",
+    isotropic=True,
+  )
+
+  after = env.sim.model.pair_friction
+  # Axis 3 was randomized.
+  assert not torch.allclose(after[:, pair_ids, 3], before[:, pair_ids, 3])
+  # Axis 4 equals axis 3 exactly (dict-int ranges must trigger the roll copy).
+  assert torch.allclose(after[:, pair_ids, 4], after[:, pair_ids, 3])
+  # Tangent and spin axes untouched.
+  for ax in (0, 1, 2):
+    assert torch.allclose(after[:, pair_ids, ax], before[:, pair_ids, ax])
+
+
+def test_pair_friction_invalid_name(pair_env):
+  """ValueError for unknown pair name."""
+  env = pair_env
+
+  with pytest.raises(ValueError, match="nonexistent_pair"):
+    cfg = SceneEntityCfg("robot", pair_names=("nonexistent_pair",))
+    cfg.resolve(env.scene)
diff --git a/tests/test_encoder_bias.py b/tests/test_encoder_bias.py
new file mode 100644
index 0000000..7aeb97f
--- /dev/null
+++ b/tests/test_encoder_bias.py
@@ -0,0 +1,304 @@
+"""Tests for encoder bias simulation.
+
+We simulate this by storing `encoder_bias` per joint in EntityData:
+  - Observations: policy sees (true_position + bias)
+  - Actions: position commands are converted via (command - bias) before simulation
+
+This ensures joint limits apply to the true physical position, not biased readings.
+"""
+
+from collections.abc import Callable
+from functools import partial
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.actuator import BuiltinPositionActuatorCfg
+from mjlab.entity import EntityArticulationInfoCfg, EntityCfg
+from mjlab.envs import ManagerBasedRlEnv, ManagerBasedRlEnvCfg, mdp
+from mjlab.managers.event_manager import EventTermCfg
+from mjlab.managers.observation_manager import ObservationGroupCfg, ObservationTermCfg
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.scene import SceneCfg
+from mjlab.sim import MujocoCfg, SimulationCfg
+from mjlab.terrains import TerrainEntityCfg
+
+# =============================================================================
+# Test fixtures and helpers
+# =============================================================================
+
+SLIDING_MASS_XML = """
+<mujoco>
+  <option timestep="0.002"/>
+  <worldbody>
+    <body name="mass" pos="0 0 0">
+      <joint name="slide" type="slide" axis="1 0 0" range="-1 1" limited="true"/>
+      <geom name="mass_geom" type="sphere" size="0.1" mass="1.0"/>
+    </body>
+  </worldbody>
+  <sensor>
+    <jointpos name="slide_pos" joint="slide"/>
+  </sensor>
+</mujoco>
+"""
+
+
+def _make_robot_cfg():
+  return EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(SLIDING_MASS_XML),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinPositionActuatorCfg(
+          target_names_expr=(".*",), stiffness=1000.0, damping=100.0
+        ),
+      )
+    ),
+  )
+
+
+def _make_env_cfg(
+  obs_func: Callable | None = None,
+  num_envs: int = 2,
+  events: dict | None = None,
+) -> ManagerBasedRlEnvCfg:
+  if obs_func is None:
+    obs_func = partial(mdp.joint_pos_rel, biased=True)
+  return ManagerBasedRlEnvCfg(
+    scene=SceneCfg(
+      terrain=TerrainEntityCfg(terrain_type="plane"),
+      num_envs=num_envs,
+      extent=1.0,
+      entities={"robot": _make_robot_cfg()},
+    ),
+    observations={
+      "actor": ObservationGroupCfg(
+        terms={"obs": ObservationTermCfg(func=obs_func)},
+      ),
+    },
+    actions={
+      "joint_pos": mdp.JointPositionActionCfg(
+        entity_name="robot", actuator_names=(".*",), scale=1.0
+      )
+    },
+    events=events or {},
+    sim=SimulationCfg(mujoco=MujocoCfg(timestep=0.002, iterations=1)),
+    decimation=1,
+    episode_length_s=10.0,
+  )
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+# =============================================================================
+# EntityData.encoder_bias field tests
+# =============================================================================
+
+
+def test_encoder_bias_initialized_to_zero(device):
+  """encoder_bias should be zeros with shape (num_envs, num_joints)."""
+  env = ManagerBasedRlEnv(cfg=_make_env_cfg(num_envs=4), device=device)
+  env.reset()
+
+  robot = env.scene["robot"]
+  assert robot.data.encoder_bias.shape == (4, 1)
+  assert (robot.data.encoder_bias == 0).all()
+
+  env.close()
+
+
+def test_encoder_bias_can_be_set_per_env(device):
+  """encoder_bias can be set differently per environment."""
+  env = ManagerBasedRlEnv(cfg=_make_env_cfg(), device=device)
+  env.reset()
+
+  robot = env.scene["robot"]
+  robot.data.encoder_bias[0, 0] = 0.1
+  robot.data.encoder_bias[1, 0] = -0.2
+
+  assert robot.data.encoder_bias[0, 0].item() == pytest.approx(0.1)
+  assert robot.data.encoder_bias[1, 0].item() == pytest.approx(-0.2)
+
+  env.close()
+
+
+def test_joint_pos_biased_equals_joint_pos_plus_bias(device):
+  """joint_pos_biased property should return joint_pos + encoder_bias."""
+  env = ManagerBasedRlEnv(cfg=_make_env_cfg(), device=device)
+  env.reset()
+
+  robot = env.scene["robot"]
+  robot.data.encoder_bias[:, 0] = 0.25
+
+  torch.testing.assert_close(
+    robot.data.joint_pos_biased, robot.data.joint_pos + robot.data.encoder_bias
+  )
+
+  env.close()
+
+
+# =============================================================================
+# Observation tests
+# =============================================================================
+
+
+def test_joint_pos_rel_includes_encoder_bias(device):
+  """joint_pos_rel observation should include encoder_bias."""
+  env = ManagerBasedRlEnv(cfg=_make_env_cfg(), device=device)
+  env.reset()
+
+  robot = env.scene["robot"]
+  bias = 0.5
+
+  obs_before = env.observation_manager.compute()["actor"]
+  assert isinstance(obs_before, torch.Tensor)
+  obs_before = obs_before.clone()
+  robot.data.encoder_bias[:, 0] = bias
+  env.observation_manager._obs_buffer = None  # Invalidate cache.
+  obs_after = env.observation_manager.compute()["actor"]
+
+  # Observation should increase by bias amount.
+  torch.testing.assert_close(obs_after, obs_before + bias, atol=1e-5, rtol=0)
+
+  env.close()
+
+
+def test_joint_vel_rel_ignores_encoder_bias(device):
+  """joint_vel_rel should NOT include encoder_bias (bias is constant, d/dt = 0)."""
+  env = ManagerBasedRlEnv(cfg=_make_env_cfg(obs_func=mdp.joint_vel_rel), device=device)
+  env.reset()
+
+  robot = env.scene["robot"]
+
+  obs_before = env.observation_manager.compute()["actor"]
+  assert isinstance(obs_before, torch.Tensor)
+  obs_before = obs_before.clone()
+  robot.data.encoder_bias[:, 0] = 0.5
+  env.observation_manager._obs_buffer = None
+  obs_after = env.observation_manager.compute()["actor"]
+
+  torch.testing.assert_close(obs_before, obs_after, atol=1e-6, rtol=0)
+
+  env.close()
+
+
+# =============================================================================
+# Action tests
+# =============================================================================
+
+
+def test_position_action_subtracts_encoder_bias(device):
+  """JointPositionAction should subtract encoder_bias from commands."""
+  env = ManagerBasedRlEnv(cfg=_make_env_cfg(), device=device)
+  env.reset()
+
+  robot = env.scene["robot"]
+  robot.data.encoder_bias[0, 0] = 0.0
+  robot.data.encoder_bias[1, 0] = 0.3
+
+  # Same command to both envs.
+  env.step(torch.tensor([[0.5], [0.5]], device=device))
+
+  # Actual targets should differ by bias.
+  assert robot.data.joint_pos_target[0, 0].item() == pytest.approx(0.5, abs=1e-5)
+  assert robot.data.joint_pos_target[1, 0].item() == pytest.approx(0.2, abs=1e-5)
+
+  env.close()
+
+
+# =============================================================================
+# End-to-end consistency test
+# =============================================================================
+
+
+def test_bias_compensation_produces_identical_physical_behavior(device):
+  """Envs with different biases should have identical physics when compensated.
+
+  If env0 has bias=0 and env1 has bias=0.3, and we want both to reach physical
+  position 0.4, we command:
+    - env0: 0.4 (in encoder frame)
+    - env1: 0.7 (in encoder frame, which becomes 0.4 after bias subtraction)
+
+  Both should reach the same physical position. Their observations should differ
+  by the bias amount.
+  """
+  env = ManagerBasedRlEnv(cfg=_make_env_cfg(), device=device)
+  env.reset()
+
+  robot = env.scene["robot"]
+  bias_env0, bias_env1 = 0.0, 0.3
+  robot.data.encoder_bias[0, 0] = bias_env0
+  robot.data.encoder_bias[1, 0] = bias_env1
+
+  # Command same physical target via encoder frame.
+  target_physical = 0.4
+  action = torch.tensor(
+    [[target_physical + bias_env0], [target_physical + bias_env1]], device=device
+  )
+
+  for _ in range(100):
+    env.step(action)
+
+  # Physical positions should match.
+  pos_env0 = robot.data.joint_pos[0, 0].item()
+  pos_env1 = robot.data.joint_pos[1, 0].item()
+  assert pos_env0 == pytest.approx(pos_env1, abs=1e-4)
+
+  # Observations should differ by bias.
+  env.observation_manager._obs_buffer = None
+  obs = env.observation_manager.compute()["actor"]
+  assert isinstance(obs, torch.Tensor)
+  obs_diff = obs[1, 0].item() - obs[0, 0].item()
+  assert obs_diff == pytest.approx(bias_env1 - bias_env0, abs=1e-4)
+
+  env.close()
+
+
+# =============================================================================
+# Event randomization test
+# =============================================================================
+
+
+def test_randomize_encoder_bias_event(device):
+  """randomize_encoder_bias should sample values within specified range."""
+  env_cfg = ManagerBasedRlEnvCfg(
+    scene=SceneCfg(
+      terrain=TerrainEntityCfg(terrain_type="plane"),
+      num_envs=100,
+      extent=10.0,
+      entities={"robot": _make_robot_cfg()},
+    ),
+    observations={
+      "actor": ObservationGroupCfg(
+        terms={"obs": ObservationTermCfg(func=partial(mdp.joint_pos_rel, biased=True))},
+      ),
+    },
+    actions={
+      "joint_pos": mdp.JointPositionActionCfg(
+        entity_name="robot", actuator_names=(".*",), scale=1.0
+      )
+    },
+    events={
+      "randomize_bias": EventTermCfg(
+        func=mdp.dr.encoder_bias,
+        mode="startup",
+        params={"bias_range": (-0.1, 0.1), "asset_cfg": SceneEntityCfg("robot")},
+      )
+    },
+    sim=SimulationCfg(mujoco=MujocoCfg(timestep=0.002, iterations=1)),
+    decimation=1,
+    episode_length_s=10.0,
+  )
+
+  env = ManagerBasedRlEnv(cfg=env_cfg, device=device)
+  env.reset()
+
+  biases = env.scene["robot"].data.encoder_bias[:, 0]
+  assert (biases >= -0.1).all() and (biases <= 0.1).all()
+  assert biases.std() > 0.01  # Not all identical.
+
+  env.close()
diff --git a/tests/test_entity.py b/tests/test_entity.py
new file mode 100644
index 0000000..425c889
--- /dev/null
+++ b/tests/test_entity.py
@@ -0,0 +1,870 @@
+"""Tests for entity module."""
+
+from dataclasses import dataclass
+
+import mujoco
+import numpy as np
+import pytest
+import torch
+from conftest import get_test_device, load_fixture_xml
+
+from mjlab.actuator import BuiltinPositionActuatorCfg, XmlActuatorCfg
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.scene import Scene, SceneCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+from mjlab.utils.spec_config import CollisionCfg, GeomCfg
+
+FIXED_BASE_XML = """
+<mujoco>
+  <worldbody>
+    <body name="object" pos="0 0 0.5">
+      <geom name="object_geom" type="box" size="0.1 0.1 0.1" rgba="0.8 0.3 0.3 1"/>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+FLOATING_BASE_XML = """
+<mujoco>
+  <worldbody>
+    <body name="object" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="object_geom" type="box" size="0.1 0.1 0.1" rgba="0.3 0.3 0.8 1" mass="0.1"/>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+FIXED_BASE_ARTICULATED_XML = """
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 0.5">
+      <geom name="base_geom" type="cylinder" size="0.1 0.05" mass="5.0"/>
+      <body name="link1" pos="0 0 0.1">
+        <joint name="joint1" type="hinge" axis="0 0 1" range="-3.14 3.14"/>
+        <geom name="link1_geom" type="box" size="0.05 0.05 0.2" mass="1.0"/>
+        <body name="link2" pos="0 0 0.4">
+          <joint name="joint2" type="hinge" axis="0 1 0" range="-1.57 1.57"/>
+          <geom name="link2_geom" type="box" size="0.05 0.05 0.15" mass="0.5"/>
+        </body>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+FLOATING_BASE_ARTICULATED_XML = load_fixture_xml("floating_base_articulated")
+
+ACTUATOR_ORDER_TEST_XML = """
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 0">
+      <inertial pos="0 0 0" mass="1" diaginertia="0.01 0.01 0.01"/>
+      <geom type="box" size="0.1 0.1 0.1" rgba="0.5 0.5 0.5 1"/>
+      <joint name="joint_a" axis="1 0 0" range="-1 1"/>
+      <body name="link1" pos="0.2 0 0">
+        <inertial pos="0 0 0" mass="1" diaginertia="0.01 0.01 0.01"/>
+        <geom type="box" size="0.1 0.1 0.1" rgba="0.5 0.5 0.5 1"/>
+        <joint name="joint_b" axis="0 1 0" range="-1 1"/>
+        <body name="link2" pos="0.2 0 0">
+          <inertial pos="0 0 0" mass="1" diaginertia="0.01 0.01 0.01"/>
+          <geom type="box" size="0.1 0.1 0.1" rgba="0.5 0.5 0.5 1"/>
+          <joint name="joint_c" axis="0 0 1" range="-1 1"/>
+        </body>
+      </body>
+    </body>
+  </worldbody>
+  <actuator>
+    <position name="act_c" joint="joint_c" kp="10"/>
+    <position name="act_b" joint="joint_b" kp="10"/>
+    <position name="act_a" joint="joint_a" kp="10"/>
+  </actuator>
+</mujoco>
+"""
+
+UNDERACTUATED_XML = """
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 0">
+      <inertial pos="0 0 0" mass="1" diaginertia="0.01 0.01 0.01"/>
+      <geom type="box" size="0.1 0.1 0.1" rgba="0.5 0.5 0.5 1"/>
+      <joint name="joint_a" axis="1 0 0" range="-1 1"/>
+      <body name="link1" pos="0.2 0 0">
+        <inertial pos="0 0 0" mass="1" diaginertia="0.01 0.01 0.01"/>
+        <geom type="box" size="0.1 0.1 0.1" rgba="0.5 0.5 0.5 1"/>
+        <joint name="joint_b" axis="0 1 0" range="-1 1"/>
+        <body name="link2" pos="0.2 0 0">
+          <inertial pos="0 0 0" mass="1" diaginertia="0.01 0.01 0.01"/>
+          <geom type="box" size="0.1 0.1 0.1" rgba="0.5 0.5 0.5 1"/>
+          <joint name="joint_c" axis="0 0 1" range="-1 1"/>
+        </body>
+      </body>
+    </body>
+  </worldbody>
+  <actuator>
+    <position name="act_c" joint="joint_c" kp="10"/>
+  </actuator>
+</mujoco>
+"""
+
+
+@pytest.fixture(scope="module")
+def device():
+  """Test device fixture."""
+  return get_test_device()
+
+
+def create_fixed_base_entity():
+  """Create a simple fixed-base entity."""
+  cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(FIXED_BASE_XML))
+  return Entity(cfg)
+
+
+def create_floating_base_entity():
+  """Create a floating-base entity."""
+  cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(FLOATING_BASE_XML))
+  return Entity(cfg)
+
+
+def create_fixed_articulated_entity():
+  """Create a fixed-base articulated entity (e.g., robot arm)."""
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(FIXED_BASE_ARTICULATED_XML),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinPositionActuatorCfg(
+          target_names_expr=("joint1", "joint2"),
+          effort_limit=1.0,
+          stiffness=1.0,
+          damping=1.0,
+        ),
+      )
+    ),
+  )
+  return Entity(cfg)
+
+
+def create_floating_articulated_entity():
+  """Create a floating-base articulated entity."""
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(FLOATING_BASE_ARTICULATED_XML),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinPositionActuatorCfg(
+          target_names_expr=("joint1", "joint2"),
+          effort_limit=1.0,
+          stiffness=1.0,
+          damping=1.0,
+        ),
+      )
+    ),
+  )
+  return Entity(cfg)
+
+
+def initialize_entity_with_sim(entity, device, num_envs=1):
+  """Initialize an entity with a simulation."""
+  model = entity.compile()
+  sim_cfg = SimulationCfg(njmax=75)
+  sim = Simulation(num_envs=num_envs, cfg=sim_cfg, model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+  return entity, sim
+
+
+@pytest.mark.parametrize(
+  "entity_fn,expected",
+  [
+    (
+      create_fixed_base_entity,
+      {
+        "is_fixed_base": True,
+        "is_articulated": False,
+        "is_actuated": False,
+        "num_bodies": 2,  # mocap_base wrapper + object
+        "num_joints": 0,
+        "num_actuators": 0,
+      },
+    ),
+    (
+      create_floating_base_entity,
+      {
+        "is_fixed_base": False,
+        "is_articulated": False,
+        "is_actuated": False,
+        "num_bodies": 1,
+        "num_joints": 0,
+        "num_actuators": 0,
+      },
+    ),
+    (
+      create_fixed_articulated_entity,
+      {
+        "is_fixed_base": True,
+        "is_articulated": True,
+        "is_actuated": True,
+        "num_bodies": 4,  # mocap_base wrapper + base + link1 + link2
+        "num_joints": 2,
+        "num_actuators": 2,
+      },
+    ),
+    (
+      create_floating_articulated_entity,
+      {
+        "is_fixed_base": False,
+        "is_articulated": True,
+        "is_actuated": True,
+        "num_bodies": 3,
+        "num_joints": 2,
+        "num_actuators": 2,
+      },
+    ),
+  ],
+)
+def test_entity_properties(entity_fn, expected):
+  """Test entity type properties and element counts."""
+  entity = entity_fn()
+  for prop, value in expected.items():
+    assert getattr(entity, prop) == value
+
+
+def test_unnamed_freejoint_gets_default_name():
+  """Test that an unnamed freejoint is auto-named during entity init."""
+  xml = """
+  <mujoco>
+    <worldbody>
+      <body name="object" pos="0 0 1">
+        <freejoint/>
+        <geom name="object_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+      </body>
+    </worldbody>
+  </mujoco>
+  """
+  cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(xml))
+  entity = Entity(cfg)
+  assert "floating_base_joint" in entity.all_joint_names
+
+
+def test_multiple_freejoints_raises():
+  """An entity with more than one freejoint is rejected at construction."""
+  xml = """
+  <mujoco>
+    <worldbody>
+      <body name="object_a" pos="0 0 1">
+        <freejoint/>
+        <geom type="box" size="0.1 0.1 0.1" mass="0.1"/>
+      </body>
+      <body name="object_b" pos="1 0 1">
+        <freejoint/>
+        <geom type="box" size="0.1 0.1 0.1" mass="0.1"/>
+      </body>
+    </worldbody>
+  </mujoco>
+  """
+  cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(xml))
+  with pytest.raises(ValueError, match="2 freejoints"):
+    Entity(cfg)
+
+
+def test_geom_editor_applied():
+  """Test that geom editors are applied during entity init."""
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(FIXED_BASE_ARTICULATED_XML),
+    geoms=(GeomCfg(geom_names_expr=("link.*_geom",), group=3),),
+  )
+  entity = Entity(cfg)
+
+  assert entity.spec.geom("link1_geom").group == 3
+  assert entity.spec.geom("link2_geom").group == 3
+  assert entity.spec.geom("base_geom").group == 0
+
+
+def test_geom_collision_overlap_warns():
+  """A GeomCfg collision patch clobbered by a CollisionCfg triggers a warning."""
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(FIXED_BASE_ARTICULATED_XML),
+    geoms=(GeomCfg(geom_names_expr=("link1_geom",), condim=6),),
+    collisions=(
+      CollisionCfg(
+        geom_names_expr=("link.*_geom",), contype=1, conaffinity=1, condim=3, priority=0
+      ),
+    ),
+  )
+  with pytest.warns(UserWarning, match="link1_geom.condim"):
+    Entity(cfg)
+
+
+def test_find_methods():
+  """Test find methods with exact and regex matches."""
+  entity = create_floating_articulated_entity()
+
+  # Test exact matches.
+  assert entity.find_bodies("base")[1] == ["base"]
+  assert entity.find_joints("joint1")[1] == ["joint1"]
+  assert entity.find_sites("site1")[1] == ["site1"]
+
+  # Test regex matches.
+  assert entity.find_bodies("link.*")[1] == ["link1", "link2"]
+  assert entity.find_joints("joint.*")[1] == ["joint1", "joint2"]
+
+
+def test_find_with_subset_filtering():
+  """Test find methods with subset filtering."""
+  entity = create_floating_articulated_entity()
+
+  # Test subset filtering.
+  _, names = entity.find_joints("joint1", joint_subset=["joint1", "joint2"])
+  assert names == ["joint1"]
+
+  # Test error on invalid subset.
+  with pytest.raises(ValueError, match="Not all regular expressions are matched"):
+    entity.find_joints("joint1", joint_subset=["joint2"])
+
+
+def test_root_state_read_write(device):
+  """Test root state can be written and read from simulation."""
+  entity = create_floating_base_entity()
+  entity, sim = initialize_entity_with_sim(entity, device)
+
+  # fmt: off
+  root_state = torch.tensor([
+      1.0, 2.0, 3.0,           # position
+      1.0, 0.0, 0.0, 0.0,      # quaternion (identity)
+      0.5, 0.0, 0.0,           # linear velocity in X
+      0.0, 0.0, 0.2            # angular velocity around Z
+  ], device=device).unsqueeze(0)
+  # fmt: on
+
+  entity.write_root_state_to_sim(root_state)
+
+  # Verify the state was actually written.
+  q_slice = entity.data.indexing.free_joint_q_adr
+  v_slice = entity.data.indexing.free_joint_v_adr
+  assert torch.allclose(sim.data.qpos[:, q_slice], root_state[:, :7])
+  assert torch.allclose(sim.data.qvel[:, v_slice], root_state[:, 7:])
+
+
+def test_external_force_and_torque(device):
+  """Test forces translate, torques rotate, and forces can be cleared."""
+  entity = create_floating_base_entity()
+  entity, sim = initialize_entity_with_sim(entity, device)
+
+  # Apply force in X, torque around Z.
+  entity.write_external_wrench_to_sim(
+    forces=torch.tensor([[5.0, 0.0, 0.0]], device=sim.device),
+    torques=torch.tensor([[0.0, 0.0, 3.0]], device=sim.device),
+  )
+
+  initial_pos = sim.data.qpos[0, :3].clone()
+  initial_quat = sim.data.qpos[0, 3:7].clone()
+
+  for _ in range(10):
+    sim.step()
+
+  # Verify X translation and rotation occurred.
+  assert sim.data.qpos[0, 0] > initial_pos[0], "Force should cause X translation"
+  assert not torch.allclose(sim.data.qpos[0, 3:7], initial_quat), (
+    "Torque should cause rotation"
+  )
+
+  # Verify angular velocity is primarily around Z.
+  angular_vel = sim.data.qvel[0, 3:6]
+  z_rotation = abs(angular_vel[2])
+  xy_rotation = abs(angular_vel[0]) + abs(angular_vel[1])
+  assert z_rotation > xy_rotation * 5, "Rotation should be primarily around Z axis"
+
+
+def test_external_force_clearing(device):
+  """Test external forces can be cleared."""
+  entity = create_floating_base_entity()
+  entity, sim = initialize_entity_with_sim(entity, device)
+
+  # Apply force.
+  entity.write_external_wrench_to_sim(
+    forces=torch.tensor([[5.0, 0.0, 0.0]], device=sim.device),
+    torques=torch.tensor([[0.0, 0.0, 3.0]], device=sim.device),
+  )
+
+  # Clear forces.
+  entity.write_external_wrench_to_sim(
+    forces=torch.zeros((1, 3), device=sim.device),
+    torques=torch.zeros((1, 3), device=sim.device),
+  )
+
+  body_id = entity.indexing.body_ids[0]
+  assert torch.allclose(
+    sim.data.xfrc_applied[:, body_id, :], torch.zeros(6, device=sim.device)
+  )
+
+
+def test_external_force_on_specific_body(device):
+  """Test applying force to specific body in articulated system."""
+  entity = create_floating_articulated_entity()
+  entity, sim = initialize_entity_with_sim(entity, device)
+
+  # Apply force only to link1.
+  body_ids = entity.find_bodies("link1")[0]
+  entity.write_external_wrench_to_sim(
+    forces=torch.tensor([[3.0, 0.0, 0.0]], device=sim.device),
+    torques=torch.zeros((1, 3), device=sim.device),
+    body_ids=body_ids,
+  )
+
+  # Verify force applied only to link1.
+  link1_id = sim.mj_model.body("link1").id
+  base_id = sim.mj_model.body("base").id
+  assert torch.allclose(
+    sim.data.xfrc_applied[0, link1_id, :3],
+    torch.tensor([3.0, 0.0, 0.0], device=sim.device),
+  )
+  assert torch.allclose(
+    sim.data.xfrc_applied[0, base_id, :3], torch.zeros(3, device=sim.device)
+  )
+
+  # Verify motion occurs.
+  initial_pos = sim.data.xpos[0, link1_id, :].clone()
+  for _ in range(10):
+    sim.step()
+  assert not torch.allclose(sim.data.xpos[0, link1_id, :], initial_pos)
+
+
+def test_fixed_base_initial_position():
+  """Test fixed-base entity's initial pos/rot are applied to the mocap wrapper."""
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(FIXED_BASE_XML),
+    init_state=EntityCfg.InitialStateCfg((1.0, 2.0, 3.0), (0.7071, 0.7071, 0.0, 0.0)),
+  )
+  entity = Entity(cfg)
+  model = entity.compile()
+
+  # init_state is applied to the auto-generated mocap_base wrapper body.
+  mocap_body = model.body("mocap_base")
+  np.testing.assert_allclose(mocap_body.pos, [1.0, 2.0, 3.0], rtol=1e-6)
+  np.testing.assert_allclose(mocap_body.quat, [0.7071, 0.7071, 0.0, 0.0], atol=1e-4)
+
+
+def test_keyframe_ctrl_maps_joint_pos_to_actuators():
+  """Test keyframe ctrl values match init_state joint positions."""
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(FLOATING_BASE_ARTICULATED_XML),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinPositionActuatorCfg(
+          target_names_expr=(
+            "joint1",
+            "joint2",
+          ),
+          effort_limit=1.0,
+          stiffness=1.0,
+          damping=1.0,
+        ),
+      )
+    ),
+    init_state=EntityCfg.InitialStateCfg(joint_pos={"joint1": 0.5, "joint2": -0.25}),
+  )
+  model = Entity(cfg).compile()
+
+  assert model.nkey == 1
+  assert model.nu == 2
+  assert list(model.key("init_state").ctrl) == [0.5, -0.25]
+
+
+def test_keyframe_ctrl_underactuated():
+  """Test ctrl is correctly constructed for an underactuated system."""
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(FLOATING_BASE_ARTICULATED_XML),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinPositionActuatorCfg(
+          target_names_expr=("joint1",),  # Only one actuator.
+          effort_limit=1.0,
+          stiffness=1.0,
+          damping=1.0,
+        ),
+      )
+    ),
+    init_state=EntityCfg.InitialStateCfg(joint_pos={"joint1": 0.42, "joint2": -0.99}),
+  )
+  model = Entity(cfg).compile()
+
+  assert model.nu == 1
+  assert model.key_ctrl[0, 0] == 0.42
+
+
+def test_fixed_base_mocap_runtime_pose_change(device):
+  """Test fixed-base mocap entity can have its pose changed at runtime."""
+
+  def spec_fn():
+    spec = mujoco.MjSpec.from_string(FIXED_BASE_ARTICULATED_XML)
+    spec.worldbody.first_body().mocap = True
+    return spec
+
+  cfg = EntityCfg(
+    spec_fn=spec_fn,
+    init_state=EntityCfg.InitialStateCfg((1.0, 2.0, 3.0), (1.0, 0.0, 0.0, 0.0)),
+  )
+  entity = Entity(cfg)
+  entity, sim = initialize_entity_with_sim(entity, device)
+
+  assert entity.indexing.mocap_id is not None
+  assert entity.is_mocap is True
+
+  # fmt: off
+  new_pose = torch.tensor([
+    5.0, 6.0, 7.0,
+    1.0, 0.0, 0.0, 0.0,
+  ], device=device).unsqueeze(0)
+  # fmt: on
+  entity.write_mocap_pose_to_sim(new_pose)
+
+  sim.forward()
+  assert torch.allclose(entity.data.root_link_pose_w, new_pose, atol=1e-5)
+
+
+def test_find_joints_by_actuator_names_preserves_natural_order(device):
+  """Test that find_joints_by_actuator_names returns joints in natural joint order.
+
+  This is a regression test for a bug where joints were returned in actuator
+  definition order instead of natural joint order, breaking motion tracking tasks.
+  """
+  robot_cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(ACTUATOR_ORDER_TEST_XML),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(XmlActuatorCfg(target_names_expr=(".*",)),)
+    ),
+  )
+
+  robot = Entity(robot_cfg)
+  robot.compile()
+
+  # Natural joint order should be: joint_a, joint_b, joint_c.
+  assert list(robot.joint_names) == ["joint_a", "joint_b", "joint_c"]
+
+  # Actuator order is: act_c, act_b, act_a (reverse).
+  # But find_joints_by_actuator_names should still return joints in natural order.
+  joint_ids, joint_names = robot.find_joints_by_actuator_names(".*")
+
+  # Critical: joints must be in natural order, not actuator order.
+  assert joint_names == ["joint_a", "joint_b", "joint_c"]
+  assert joint_ids == [0, 1, 2]
+
+  # Verify this differs from actuator order (which is reverse).
+  assert list(robot.actuator_names) == ["act_c", "act_b", "act_a"]
+
+
+def test_ctrl_ids_follow_natural_joint_order(device):
+  """Test that entity.indexing.ctrl_ids are in actuator definition order.
+
+  ctrl_ids follow actuator definition order for simplicity. ONNX export builds
+  the natural joint order mapping where needed.
+  """
+  robot_cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(ACTUATOR_ORDER_TEST_XML),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(XmlActuatorCfg(target_names_expr=(".*",)),)
+    ),
+  )
+
+  robot = Entity(robot_cfg)
+  mj_model = robot.compile()
+
+  # Create simulation to initialize entity.
+  sim_cfg = SimulationCfg()
+  sim = Simulation(num_envs=1, cfg=sim_cfg, model=mj_model, device=device)
+  robot.initialize(sim.mj_model, sim.model, sim.data, device)
+
+  # Natural joint order: joint_a, joint_b, joint_c.
+  assert list(robot.joint_names) == ["joint_a", "joint_b", "joint_c"]
+
+  # Actuator definition order (from XML): act_c, act_b, act_a.
+  assert list(robot.actuator_names) == ["act_c", "act_b", "act_a"]
+
+  # ctrl_ids should be in actuator definition order (c, b, a).
+  ctrl_ids = robot.indexing.ctrl_ids.cpu().tolist()
+
+  # Map actuator names to their MuJoCo IDs in the compiled model.
+  actuator_name_to_id = {
+    mj_model.actuator(i).name.split("/")[-1]: i for i in range(mj_model.nu)
+  }
+
+  # ctrl_ids should be ordered as: act_c, act_b, act_a (actuator definition order).
+  expected_ctrl_ids = [
+    actuator_name_to_id["act_c"],
+    actuator_name_to_id["act_b"],
+    actuator_name_to_id["act_a"],
+  ]
+  assert ctrl_ids == expected_ctrl_ids
+
+
+def test_find_joints_by_actuator_names_returns_entity_local_indices():
+  """Test that find_joints_by_actuator_names returns entity-local indices."""
+  robot_cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(UNDERACTUATED_XML),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(XmlActuatorCfg(target_names_expr=(".*",)),)
+    ),
+  )
+
+  robot = Entity(robot_cfg)
+  robot.compile()
+
+  # Natural joint order: joint_a (0), joint_b (1), joint_c (2).
+  assert list(robot.joint_names) == ["joint_a", "joint_b", "joint_c"]
+
+  # Only joint_c has an actuator.
+  joint_ids, joint_names = robot.find_joints_by_actuator_names(".*")
+
+  # Should return entity-local index [2], not subset-local [0].
+  assert joint_names == ["joint_c"]
+  assert joint_ids == [2]  # Index of joint_c in self.joint_names.
+
+
+@dataclass
+class CustomEntityCfg(EntityCfg):
+  """Custom entity config with additional fields."""
+
+  custom_threshold: float = 0.5
+
+  def build(self) -> "CustomEntity":
+    return CustomEntity(self)
+
+
+class CustomEntity(Entity):
+  """Custom entity with additional properties."""
+
+  cfg: CustomEntityCfg
+
+  @property
+  def custom_value(self) -> float:
+    """Custom property that uses config field."""
+    return self.cfg.custom_threshold * 2
+
+
+def test_custom_entity_subclass(device):
+  """Test that custom Entity subclasses work through the scene."""
+  scene_cfg = SceneCfg(
+    num_envs=1,
+    entities={
+      "custom": CustomEntityCfg(
+        spec_fn=lambda: mujoco.MjSpec.from_string(FIXED_BASE_XML),
+        custom_threshold=0.9,
+      ),
+    },
+  )
+  scene = Scene(scene_cfg, device)
+
+  # Scene should have instantiated our custom entity type.
+  custom_entity = scene.entities["custom"]
+  assert isinstance(custom_entity, CustomEntity)
+  assert custom_entity.cfg.custom_threshold == 0.9
+  assert custom_entity.custom_value == 1.8
+
+
+# ============================================================================
+# Keyframe Fallback Tests
+# ============================================================================
+
+XML_WITH_KEYFRAME = """
+<mujoco>
+  <worldbody>
+    <body name="robot">
+      <freejoint name="root"/>
+      <geom type="box" size="0.1 0.1 0.1"/>
+      <body name="link" pos="0.2 0 0">
+        <joint name="joint1" type="hinge" axis="0 1 0"/>
+        <geom type="box" size="0.05 0.05 0.05"/>
+      </body>
+    </body>
+  </worldbody>
+  <keyframe>
+    <key name="home" qpos="0 0 1 1 0 0 0 0.5"/>
+  </keyframe>
+</mujoco>
+"""
+
+XML_WITHOUT_KEYFRAME = """
+<mujoco>
+  <worldbody>
+    <body name="robot">
+      <freejoint name="root"/>
+      <geom type="box" size="0.1 0.1 0.1"/>
+      <body name="link" pos="0.2 0 0">
+        <joint name="joint1" type="hinge" axis="0 1 0"/>
+        <geom type="box" size="0.05 0.05 0.05"/>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+
+def test_joint_pos_none_uses_model_keyframe():
+  """Test that joint_pos=None uses the model's existing keyframe."""
+  cfg = EntityCfg(
+    init_state=EntityCfg.InitialStateCfg(joint_pos=None),
+    spec_fn=lambda: mujoco.MjSpec.from_string(XML_WITH_KEYFRAME),
+  )
+  entity = Entity(cfg)
+  model = entity.spec.compile()
+
+  assert model.nkey == 1
+  # Keyframe: qpos="0 0 1 1 0 0 0 0.5" (root pos/quat + joint1)
+  assert model.key(0).qpos[7] == 0.5  # joint1 position
+
+
+def test_joint_pos_none_errors_without_keyframe():
+  """Test that joint_pos=None raises error if model has no keyframe."""
+  cfg = EntityCfg(
+    init_state=EntityCfg.InitialStateCfg(joint_pos=None),
+    spec_fn=lambda: mujoco.MjSpec.from_string(XML_WITHOUT_KEYFRAME),
+  )
+  with pytest.raises(ValueError, match="requires the model to have a keyframe"):
+    Entity(cfg)
+
+
+XML_FIXED_BASE_WITH_KEYFRAME = """
+<mujoco>
+  <worldbody>
+    <body name="arm">
+      <joint name="joint1" type="hinge" axis="0 0 1"/>
+      <geom type="box" size="0.1 0.1 0.1"/>
+    </body>
+  </worldbody>
+  <keyframe>
+    <key name="home" qpos="0.5"/>
+  </keyframe>
+</mujoco>
+"""
+
+
+def test_joint_pos_none_fixed_base_uses_keyframe():
+  """Test that joint_pos=None works for fixed-base entities with keyframes."""
+  cfg = EntityCfg(
+    init_state=EntityCfg.InitialStateCfg(joint_pos=None),
+    spec_fn=lambda: mujoco.MjSpec.from_string(XML_FIXED_BASE_WITH_KEYFRAME),
+  )
+  entity = Entity(cfg)
+  model = entity.spec.compile()
+
+  assert model.nkey == 1
+  assert model.key(0).qpos[0] == 0.5
+
+
+XML_WITH_SITES_AND_TENDONS = """
+<mujoco>
+  <worldbody>
+    <body name="base">
+      <joint name="joint1" type="hinge" axis="0 0 1" range="-3.14 3.14"/>
+      <geom type="box" size="0.1 0.1 0.1" mass="1.0"/>
+      <site name="site1" pos="0.1 0 0"/>
+      <site name="site2" pos="0 0.1 0"/>
+      <body name="link1" pos="0 0 0.2">
+        <joint name="joint2" type="hinge" axis="0 1 0" range="-1.57 1.57"/>
+        <geom type="box" size="0.05 0.05 0.1" mass="0.5"/>
+        <site name="site3" pos="0 0 0.1"/>
+      </body>
+    </body>
+  </worldbody>
+  <tendon>
+    <fixed name="tendon1">
+      <joint joint="joint1" coef="1.0"/>
+    </fixed>
+    <fixed name="tendon2">
+      <joint joint="joint2" coef="1.0"/>
+    </fixed>
+  </tendon>
+</mujoco>
+"""
+
+
+def test_tendon_and_site_targets_only_allocated_when_needed(device):
+  """Test that tendon/site targets are only allocated when actuators use them."""
+  from mjlab.actuator import BuiltinMotorActuatorCfg
+  from mjlab.actuator.actuator import TransmissionType
+
+  # Entity with sites and tendons but NO site/tendon actuators.
+  # Should allocate empty tensors for site and tendon targets.
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(XML_WITH_SITES_AND_TENDONS),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        # Only joint actuators, no tendon or site actuators.
+        BuiltinMotorActuatorCfg(
+          target_names_expr=("joint1",),
+          effort_limit=10.0,
+          transmission_type=TransmissionType.JOINT,
+        ),
+      )
+    ),
+  )
+
+  entity = Entity(cfg)
+  model = entity.compile()
+  sim = Simulation(num_envs=4, cfg=SimulationCfg(), model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+
+  # Verify the entity has sites and tendons.
+  assert len(entity.site_names) == 3
+  assert len(entity.tendon_names) == 2
+
+  # Verify tendon and site targets are empty (not allocated).
+  assert entity.data.site_effort_target.shape == (4, 0)
+  assert entity.data.tendon_len_target.shape == (4, 0)
+  assert entity.data.tendon_vel_target.shape == (4, 0)
+  assert entity.data.tendon_effort_target.shape == (4, 0)
+
+  # Joint targets should still be allocated (2 joints).
+  assert entity.data.joint_pos_target.shape == (4, 2)
+
+
+def test_add_actuators_wrong_namespace_error_includes_hint():
+  """Error message includes namespace hint when name exists in another namespace."""
+  from mjlab.actuator.actuator import TransmissionType
+
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(XML_WITH_SITES_AND_TENDONS),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinPositionActuatorCfg(
+          target_names_expr=("tendon1",),
+          stiffness=10.0,
+          damping=1.0,
+          transmission_type=TransmissionType.JOINT,
+        ),
+      )
+    ),
+  )
+  with pytest.raises(ValueError, match="Matches were found in.*tendons.*tendon1"):
+    Entity(cfg)
+
+
+@pytest.mark.filterwarnings("ignore:Actuator config matched")
+def test_wildcard_warns_about_unactuated_namespaces():
+  """Wildcard matching joints should warn about unactuated tendons."""
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(XML_WITH_SITES_AND_TENDONS),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinPositionActuatorCfg(
+          target_names_expr=(".*",),
+          stiffness=10.0,
+          damping=1.0,
+        ),
+      )
+    ),
+  )
+  with pytest.warns(match="also match.*tendon"):
+    Entity(cfg)
+
+
+def test_set_joint_position_target_outer_product(device):
+  """Tensor env_ids + tensor joint_ids select the outer product, not a diagonal."""
+  entity = create_fixed_articulated_entity()
+  entity, _ = initialize_entity_with_sim(entity, device, num_envs=2)
+
+  targets = torch.tensor([[1.0, 2.0], [3.0, 4.0]], device=device)
+  entity.set_joint_position_target(
+    targets,
+    joint_ids=torch.tensor([0, 1], device=device),
+    env_ids=torch.tensor([0, 1], device=device),
+  )
+  assert torch.equal(entity.data.joint_pos_target, targets)
diff --git a/tests/test_entity_data.py b/tests/test_entity_data.py
new file mode 100644
index 0000000..7413738
--- /dev/null
+++ b/tests/test_entity_data.py
@@ -0,0 +1,581 @@
+"""Tests for EntityData."""
+
+import math
+from pathlib import Path
+
+import mujoco
+import numpy as np
+import pytest
+import torch
+from conftest import (
+  create_entity_with_actuator,
+  get_test_device,
+  initialize_entity,
+  load_fixture_xml,
+)
+
+from mjlab.actuator import BuiltinMotorActuatorCfg
+from mjlab.actuator.actuator import TransmissionType
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+from mjlab.utils.lab_api.math import quat_apply, quat_apply_inverse
+
+FLOATING_BASE_XML = """
+<mujoco>
+  <worldbody>
+    <body name="object" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="object_geom" type="box" size="0.1 0.1 0.1" rgba="0.3 0.3 0.8 1" mass="0.1"/>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+FLOATING_BASE_COM_OFFSET_XML = """
+<mujoco>
+  <worldbody>
+    <body name="object" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <inertial pos="0.1 0.05 0" mass="1" diaginertia="0.01 0.01 0.01"/>
+      <geom type="box" size="0.1 0.1 0.1"/>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+
+@pytest.fixture(scope="module")
+def device():
+  """Test device fixture."""
+  return get_test_device()
+
+
+def create_floating_base_entity():
+  """Create a floating-base entity."""
+  cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(FLOATING_BASE_XML))
+  return Entity(cfg)
+
+
+def initialize_entity_with_sim(entity, device, num_envs=1):
+  """Initialize an entity with a simulation."""
+  model = entity.compile()
+  sim_cfg = SimulationCfg()
+  sim = Simulation(num_envs=num_envs, cfg=sim_cfg, model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+  return entity, sim
+
+
+def test_root_velocity_world_frame_roundtrip(device):
+  """Test reading and writing root velocity is a no-op (world frame).
+
+  Verifies that the API is consistent: if you write a velocity, read it
+  back, and write it again, you get the same result. This ensures no
+  unintended transformations happen in the read/write cycle.
+  """
+  entity = create_floating_base_entity()
+  entity, sim = initialize_entity_with_sim(entity, device)
+
+  pose = torch.tensor([0.0, 0.0, 1.0, 0.6, 0.2, 0.3, 0.7141], device=device).unsqueeze(
+    0
+  )
+  entity.write_root_link_pose_to_sim(pose)
+
+  vel_w = torch.tensor([1.0, 0.5, 0.0, 0.0, 0.3, 0.1], device=device).unsqueeze(0)
+  entity.write_root_link_velocity_to_sim(vel_w)
+  sim.forward()
+
+  vel_w_read = entity.data.root_link_vel_w.clone()
+  assert torch.allclose(vel_w_read, vel_w, atol=1e-4)
+
+  entity.write_root_link_velocity_to_sim(vel_w_read)
+  sim.forward()
+  vel_w_after = entity.data.root_link_vel_w
+
+  assert torch.allclose(vel_w_after, vel_w_read, atol=1e-4)
+
+
+def test_root_velocity_frame_conversion(device):
+  """Test angular velocity converts from world to body frame internally.
+
+  The API accepts angular velocity in world frame, but MuJoCo's qvel
+  stores it in body frame. This test verifies the conversion happens
+  correctly by checking qvel directly.
+  """
+  entity = create_floating_base_entity()
+  entity, sim = initialize_entity_with_sim(entity, device)
+
+  quat_w = torch.tensor([0.6, 0.2, 0.3, 0.7141], device=device).unsqueeze(0)
+  pose = torch.cat([torch.zeros(1, 3, device=device), quat_w], dim=-1)
+  entity.write_root_link_pose_to_sim(pose)
+
+  lin_vel_w = torch.tensor([1.0, 0.5, 0.2], device=device).unsqueeze(0)
+  ang_vel_w = torch.tensor([0.1, 0.2, 0.3], device=device).unsqueeze(0)
+  vel_w = torch.cat([lin_vel_w, ang_vel_w], dim=-1)
+  entity.write_root_link_velocity_to_sim(vel_w)
+
+  v_slice = entity.data.indexing.free_joint_v_adr
+  qvel = sim.data.qvel[:, v_slice]
+
+  assert torch.allclose(qvel[:, :3], lin_vel_w, atol=1e-5)
+
+  expected_ang_vel_b = quat_apply_inverse(quat_w, ang_vel_w)
+  assert torch.allclose(qvel[:, 3:], expected_ang_vel_b, atol=1e-5)
+
+
+def test_write_velocity_uses_qpos_not_xquat(device):
+  """Test write_root_velocity uses qpos (not stale xquat).
+
+  Writing pose then velocity without forward() must work. This would fail
+  if write_root_velocity used xquat (stale) instead of qpos (current).
+  """
+  entity = create_floating_base_entity()
+  entity, sim = initialize_entity_with_sim(entity, device)
+
+  initial_pose = torch.tensor(
+    [0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0], device=device
+  ).unsqueeze(0)
+  entity.write_root_link_pose_to_sim(initial_pose)
+  sim.forward()  # xquat now has identity orientation.
+
+  # Write different orientation without forward() - xquat stale, qpos current.
+  new_pose = torch.tensor(
+    [0.0, 0.0, 1.0, 0.707, 0.0, 0.707, 0.0], device=device
+  ).unsqueeze(0)
+  vel_w = torch.tensor([1.0, 0.0, 0.0, 0.0, 1.0, 0.0], device=device).unsqueeze(0)
+
+  entity.write_root_link_pose_to_sim(new_pose)
+  entity.write_root_link_velocity_to_sim(vel_w)
+
+  sim.forward()
+  vel_w_read = entity.data.root_link_vel_w
+
+  assert torch.allclose(vel_w_read, vel_w, atol=1e-4)
+
+
+def test_write_root_com_velocity(device):
+  """COM velocity write must produce the same qvel as manual conversion."""
+  num_envs = 4
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(FLOATING_BASE_COM_OFFSET_XML)
+  )
+  entity = Entity(cfg)
+  entity, sim = initialize_entity_with_sim(entity, device, num_envs=num_envs)
+
+  # Give each env a different non-identity orientation.
+  pose = torch.zeros(num_envs, 7, device=device)
+  pose[:, 2] = 1.0
+  quats = torch.tensor(
+    [
+      [1.0, 0.0, 0.0, 0.0],
+      [0.707, 0.707, 0.0, 0.0],
+      [0.5, 0.5, 0.5, 0.5],
+      [0.0, 0.707, 0.0, 0.707],
+    ],
+    device=device,
+  )
+  pose[:, 3:7] = quats
+  entity.write_root_link_pose_to_sim(pose)
+
+  com_vel = torch.tensor(
+    [[1.0, 0.5, -0.2, 0.1, 0.2, 0.3], [-0.5, 1.0, 0.0, -0.1, 0.0, 0.4]],
+    device=device,
+  )
+  env_ids = torch.tensor([1, 3], device=device)
+
+  # Write COM velocity via the API.
+  entity.write_root_com_velocity_to_sim(com_vel, env_ids=env_ids)
+  qvel_from_api = sim.data.qvel.clone()
+
+  # Manually convert COM velocity to link velocity and write that instead.
+  com_offset_b = sim.model.body_ipos[:, entity.indexing.root_body_id]
+  com_offset_w = quat_apply(quats[env_ids], com_offset_b[env_ids])
+  lin_vel_link = com_vel[:, :3] - torch.cross(com_vel[:, 3:], com_offset_w, dim=-1)
+  link_vel = torch.cat([lin_vel_link, com_vel[:, 3:]], dim=-1)
+  entity.write_root_link_velocity_to_sim(link_vel, env_ids=env_ids)
+  qvel_from_manual = sim.data.qvel.clone()
+
+  assert torch.allclose(qvel_from_api, qvel_from_manual, atol=1e-5)
+
+  # Untouched envs should have zero velocity.
+  v_adr = entity.indexing.free_joint_v_adr
+  assert torch.all(qvel_from_api[0, v_adr] == 0.0)
+  assert torch.all(qvel_from_api[2, v_adr] == 0.0)
+
+
+def test_read_requires_forward_to_be_current(device):
+  """Test read properties are stale until forward() is called.
+
+  Demonstrates why event order matters and why forward() is needed
+  between writes and reads.
+  """
+  entity = create_floating_base_entity()
+  entity, sim = initialize_entity_with_sim(entity, device)
+
+  sim.forward()
+  initial_pose = entity.data.root_link_pose_w.clone()
+
+  new_pose = torch.tensor(
+    [1.0, 2.0, 3.0, 0.707, 0.0, 0.707, 0.0], device=device
+  ).unsqueeze(0)
+  entity.write_root_link_pose_to_sim(new_pose)
+
+  stale_pose = entity.data.root_link_pose_w
+  assert torch.allclose(stale_pose, initial_pose, atol=1e-5)
+
+  sim.forward()
+  current_pose = entity.data.root_link_pose_w
+  assert torch.allclose(current_pose, new_pose, atol=1e-4)
+  assert not torch.allclose(current_pose, initial_pose, atol=1e-4)
+
+
+@pytest.mark.parametrize(
+  "property_name,expected_shape",
+  [
+    # Root properties.
+    ("root_link_pose_w", (1, 7)),
+    ("root_link_pos_w", (1, 3)),
+    ("root_link_quat_w", (1, 4)),
+    ("root_link_vel_w", (1, 6)),
+    ("root_link_lin_vel_w", (1, 3)),
+    ("root_link_ang_vel_w", (1, 3)),
+    ("root_com_pose_w", (1, 7)),
+    ("root_com_pos_w", (1, 3)),
+    ("root_com_quat_w", (1, 4)),
+    ("root_com_vel_w", (1, 6)),
+    ("root_com_lin_vel_w", (1, 3)),
+    ("root_com_ang_vel_w", (1, 3)),
+    # Body properties (we only have 1 body in this test).
+    ("body_link_pose_w", (1, 1, 7)),
+    ("body_link_pos_w", (1, 1, 3)),
+    ("body_link_quat_w", (1, 1, 4)),
+    ("body_link_vel_w", (1, 1, 6)),
+    ("body_com_pose_w", (1, 1, 7)),
+    ("body_com_vel_w", (1, 1, 6)),
+  ],
+)
+def test_entity_data_properties_accessible(device, property_name, expected_shape):
+  """Test that all EntityData properties can be accessed without errors."""
+  entity = create_floating_base_entity()
+  entity, sim = initialize_entity_with_sim(entity, device)
+
+  sim.forward()
+
+  value = getattr(entity.data, property_name)
+  assert value.shape == expected_shape, f"{property_name} has unexpected shape"
+
+
+def test_entity_data_reset_clears_all_targets(device):
+  """Test that EntityData.clear_state() zeros out all target buffers."""
+  xml_path = Path(__file__).parent / "fixtures" / "tendon_finger.xml"
+
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_file(str(xml_path)),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinMotorActuatorCfg(
+          target_names_expr=("finger_tendon",),
+          transmission_type=TransmissionType.TENDON,
+          effort_limit=10.0,
+        ),
+      )
+    ),
+  )
+  entity = Entity(cfg)
+  entity, sim = initialize_entity_with_sim(entity, device, num_envs=4)
+
+  entity.data.joint_pos_target[:] = 1.0
+  entity.data.joint_vel_target[:] = 2.0
+  entity.data.joint_effort_target[:] = 3.0
+  entity.data.tendon_len_target[:] = 4.0
+  entity.data.tendon_vel_target[:] = 5.0
+  entity.data.tendon_effort_target[:] = 6.0
+
+  entity.data.clear_state()
+
+  assert torch.all(entity.data.joint_pos_target == 0.0)
+  assert torch.all(entity.data.joint_vel_target == 0.0)
+  assert torch.all(entity.data.joint_effort_target == 0.0)
+  assert torch.all(entity.data.tendon_len_target == 0.0)
+  assert torch.all(entity.data.tendon_vel_target == 0.0)
+  assert torch.all(entity.data.tendon_effort_target == 0.0)
+
+
+def test_entity_data_reset_partial_envs(device):
+  """Test that EntityData.clear_state() can reset specific environments."""
+  xml_path = Path(__file__).parent / "fixtures" / "tendon_finger.xml"
+
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_file(str(xml_path)),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinMotorActuatorCfg(
+          target_names_expr=("finger_tendon",),
+          transmission_type=TransmissionType.TENDON,
+          effort_limit=10.0,
+        ),
+      )
+    ),
+  )
+  entity = Entity(cfg)
+  entity, sim = initialize_entity_with_sim(entity, device, num_envs=4)
+
+  entity.data.tendon_len_target[:] = 7.0
+  entity.data.tendon_vel_target[:] = 8.0
+  entity.data.tendon_effort_target[:] = 9.0
+
+  env_ids = torch.tensor([1, 3], device=device)
+  entity.data.clear_state(env_ids)
+
+  assert torch.all(entity.data.tendon_len_target[0] == 7.0)
+  assert torch.all(entity.data.tendon_len_target[1] == 0.0)
+  assert torch.all(entity.data.tendon_len_target[2] == 7.0)
+  assert torch.all(entity.data.tendon_len_target[3] == 0.0)
+
+  assert torch.all(entity.data.tendon_vel_target[0] == 8.0)
+  assert torch.all(entity.data.tendon_vel_target[1] == 0.0)
+  assert torch.all(entity.data.tendon_vel_target[2] == 8.0)
+  assert torch.all(entity.data.tendon_vel_target[3] == 0.0)
+
+  assert torch.all(entity.data.tendon_effort_target[0] == 9.0)
+  assert torch.all(entity.data.tendon_effort_target[1] == 0.0)
+  assert torch.all(entity.data.tendon_effort_target[2] == 9.0)
+  assert torch.all(entity.data.tendon_effort_target[3] == 0.0)
+
+
+# Joint limits tests.
+
+MIXED_LIMITS_XML = """
+<mujoco>
+  <worldbody>
+    <body name="base">
+      <body name="cart" pos="0 0 1">
+        <joint name="slider" type="slide" axis="1 0 0" limited="true" range="-2 2"/>
+        <geom type="box" size="0.1 0.1 0.1" mass="1"/>
+        <body name="pole">
+          <joint name="hinge" type="hinge" axis="0 1 0"/>
+          <geom type="capsule" fromto="0 0 0 0 0 0.5" size="0.02" mass="0.1"/>
+        </body>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+ALL_LIMITED_XML = """
+<mujoco>
+  <worldbody>
+    <body name="base">
+      <body name="link1" pos="0 0 0.1">
+        <joint name="j1" type="hinge" axis="0 0 1" limited="true" range="-1.5 1.5"/>
+        <geom type="box" size="0.05 0.05 0.1" mass="1"/>
+        <body name="link2" pos="0 0 0.2">
+          <joint name="j2" type="hinge" axis="0 1 0" limited="true" range="-1 1"/>
+          <geom type="box" size="0.05 0.05 0.1" mass="0.5"/>
+        </body>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+ALL_UNLIMITED_XML = """
+<mujoco>
+  <worldbody>
+    <body name="base">
+      <body name="link1" pos="0 0 0.1">
+        <joint name="j1" type="hinge" axis="0 0 1"/>
+        <geom type="box" size="0.05 0.05 0.1" mass="1"/>
+        <body name="link2" pos="0 0 0.2">
+          <joint name="j2" type="hinge" axis="0 1 0"/>
+          <geom type="box" size="0.05 0.05 0.1" mass="0.5"/>
+        </body>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+
+def test_soft_limits_unlimited_joints_are_infinite(device):
+  """Unlimited joints must have [-inf, inf] soft limits, not [0, 0]."""
+  cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(MIXED_LIMITS_XML))
+  entity = Entity(cfg)
+  entity, _ = initialize_entity_with_sim(entity, device)
+
+  limits = entity.data.soft_joint_pos_limits[0]
+  # slider (index 0) is limited: finite limits.
+  assert torch.isfinite(limits[0, 0]) and torch.isfinite(limits[0, 1])
+  assert limits[0, 0] == -2.0
+  assert limits[0, 1] == 2.0
+  # hinge (index 1) is unlimited: infinite limits.
+  assert limits[1, 0] == float("-inf")
+  assert limits[1, 1] == float("inf")
+
+
+def test_soft_limits_all_limited(device):
+  """All-limited joints should have finite soft limits."""
+  cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(ALL_LIMITED_XML))
+  entity = Entity(cfg)
+  entity, _ = initialize_entity_with_sim(entity, device)
+
+  limits = entity.data.soft_joint_pos_limits[0]
+  for j in range(limits.shape[0]):
+    assert torch.isfinite(limits[j, 0]) and torch.isfinite(limits[j, 1])
+
+
+def test_soft_limits_all_unlimited(device):
+  """All-unlimited joints should have infinite soft limits."""
+  cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(ALL_UNLIMITED_XML))
+  entity = Entity(cfg)
+  entity, _ = initialize_entity_with_sim(entity, device)
+
+  limits = entity.data.soft_joint_pos_limits[0]
+  for j in range(limits.shape[0]):
+    assert limits[j, 0] == float("-inf")
+    assert limits[j, 1] == float("inf")
+
+
+def test_joint_pos_limits_match_soft_limits_for_unlimited(device):
+  """joint_pos_limits and default_joint_pos_limits should also be inf for unlimited."""
+  cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(MIXED_LIMITS_XML))
+  entity = Entity(cfg)
+  entity, _ = initialize_entity_with_sim(entity, device)
+
+  # Hinge is joint index 1, unlimited.
+  for limits_tensor in (
+    entity.data.joint_pos_limits,
+    entity.data.default_joint_pos_limits,
+    entity.data.soft_joint_pos_limits,
+  ):
+    assert limits_tensor[0, 1, 0] == float("-inf")
+    assert limits_tensor[0, 1, 1] == float("inf")
+
+
+def test_reset_joints_by_offset_respects_unlimited(device):
+  """reset_joints_by_offset must not clamp unlimited joints to [0, 0]."""
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(MIXED_LIMITS_XML),
+    init_state=EntityCfg.InitialStateCfg(
+      joint_pos={"slider": 0.0, "hinge": math.pi},
+      joint_vel={".*": 0.0},
+    ),
+  )
+  entity = Entity(cfg)
+  entity, _ = initialize_entity_with_sim(entity, device)
+
+  # Simulate what reset_joints_by_offset does.
+  default_pos = entity.data.default_joint_pos
+  soft_limits = entity.data.soft_joint_pos_limits
+  joint_pos = default_pos.clone()
+  joint_pos = joint_pos.clamp_(soft_limits[..., 0], soft_limits[..., 1])
+
+  # Hinge should stay at pi, not get clamped to 0.
+  assert torch.allclose(
+    joint_pos[0, 1], torch.tensor(math.pi, device=device), atol=1e-5
+  )
+
+
+# Generalized force accessor tests.
+
+TWO_LINK_ARM_XML = """
+<mujoco>
+  <worldbody>
+    <body name="base">
+      <body name="upper" pos="0 0 0.5">
+        <joint name="shoulder" type="hinge" axis="0 1 0"/>
+        <geom type="capsule" fromto="0 0 0 0 0 0.4" size="0.03" mass="1.0"/>
+        <body name="lower" pos="0 0 0.4">
+          <joint name="elbow" type="hinge" axis="0 1 0"/>
+          <geom type="capsule" fromto="0 0 0 0 0 0.3" size="0.02" mass="0.5"/>
+        </body>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+
+def test_qfrc_actuator_slices_joint_dofs_only(device):
+  """qfrc_actuator should expose only articulated joint DoFs."""
+  xml = load_fixture_xml("floating_base_articulated")
+  cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(xml))
+  entity = Entity(cfg)
+  entity, sim = initialize_entity_with_sim(entity, device)
+
+  joint_v_adr = entity.indexing.joint_v_adr
+  free_v_adr = entity.indexing.free_joint_v_adr
+  nv = sim.data.qvel.shape[1]
+
+  values = torch.arange(1, nv + 1, device=device, dtype=torch.float32)
+  sim.data.qfrc_actuator[0] = values
+  expected = values[joint_v_adr]
+  actual = entity.data.qfrc_actuator[0]
+  assert torch.equal(actual, expected)
+
+  assert free_v_adr.numel() > 0
+  assert entity.data.qfrc_actuator.shape[-1] == joint_v_adr.numel()
+  assert entity.data.qfrc_actuator.shape[-1] != free_v_adr.numel()
+
+
+def test_qfrc_actuator_matches_motor_command_with_gear(device):
+  """qfrc_actuator should equal actuator_force projected through joint gear."""
+  xml = load_fixture_xml("fixed_base_articulated")
+  entity = create_entity_with_actuator(
+    xml,
+    BuiltinMotorActuatorCfg(
+      target_names_expr=("joint.*",),
+      effort_limit=100.0,
+      gear=3.0,
+    ),
+  )
+  entity, sim = initialize_entity(entity, device)
+
+  commanded = torch.tensor([[2.0, -1.0]], device=device)
+  entity.set_joint_effort_target(commanded)
+  entity.write_data_to_sim()
+  sim.forward()
+
+  assert torch.allclose(entity.data.actuator_force, commanded, atol=1e-6)
+  assert torch.allclose(entity.data.qfrc_actuator, 3.0 * commanded, atol=1e-6)
+
+
+def test_qfrc_external_matches_mj_applyFT(device):
+  """qfrc_external should match J^T * xfrc_applied computed by CPU MuJoCo."""
+  cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(TWO_LINK_ARM_XML))
+  entity = Entity(cfg)
+  entity, sim = initialize_entity_with_sim(entity, device)
+
+  entity.write_joint_state_to_sim(
+    torch.tensor([[0.5, -0.3]], device=device),
+    torch.tensor([[0.0, 0.0]], device=device),
+  )
+  sim.forward()
+
+  lower_body_id = int(entity.indexing.body_ids[1].item())
+  force = torch.tensor([1.0, 0.0, -2.0], device=device)
+  torque = torch.tensor([0.0, 0.5, 0.0], device=device)
+  sim.data.xfrc_applied[0, lower_body_id, 0:3] = force
+  sim.data.xfrc_applied[0, lower_body_id, 3:6] = torque
+  sim.forward()
+
+  mjd = mujoco.MjData(sim.mj_model)
+  mjd.qpos[:] = sim.data.qpos[0].cpu().numpy()
+  mjd.qvel[:] = sim.data.qvel[0].cpu().numpy()
+  mujoco.mj_forward(sim.mj_model, mjd)
+
+  qfrc_reference = np.zeros(sim.mj_model.nv)
+  mujoco.mj_applyFT(
+    sim.mj_model,
+    mjd,
+    force.cpu().numpy().astype(np.float64),
+    torque.cpu().numpy().astype(np.float64),
+    mjd.xipos[lower_body_id],
+    lower_body_id,
+    qfrc_reference,
+  )
+  expected = torch.from_numpy(qfrc_reference).to(device=device, dtype=torch.float32)
+
+  joint_v_adr = entity.indexing.joint_v_adr
+  assert torch.allclose(
+    entity.data.qfrc_external, expected[joint_v_adr].unsqueeze(0), atol=1e-5
+  )
diff --git a/tests/test_envs_curriculums.py b/tests/test_envs_curriculums.py
new file mode 100644
index 0000000..477b131
--- /dev/null
+++ b/tests/test_envs_curriculums.py
@@ -0,0 +1,275 @@
+"""Tests for reward_curriculum and termination_curriculum."""
+
+from unittest.mock import Mock
+
+import pytest
+import torch
+
+from mjlab.envs.mdp.curriculums import reward_curriculum, termination_curriculum
+from mjlab.managers.curriculum_manager import CurriculumTermCfg
+from mjlab.managers.reward_manager import RewardTermCfg
+from mjlab.managers.termination_manager import TerminationTermCfg
+
+
+def _reward_func(env):
+  return torch.ones(env.num_envs)
+
+
+def _termination_func(env):
+  return torch.zeros(env.num_envs, dtype=torch.bool)
+
+
+def _make_reward_cfg(
+  weight: float = 1.0,
+  params: dict | None = None,
+) -> RewardTermCfg:
+  return RewardTermCfg(
+    func=_reward_func,
+    weight=weight,
+    params=params if params is not None else {"std": 0.5, "scale": 1.0},
+  )
+
+
+def _make_termination_cfg(
+  params: dict | None = None,
+) -> TerminationTermCfg:
+  return TerminationTermCfg(
+    func=_termination_func,
+    params=params if params is not None else {"threshold": float("inf")},
+  )
+
+
+def _build_reward(env, reward_name, stages):
+  params = {"reward_name": reward_name, "stages": stages}
+  cfg = CurriculumTermCfg(func=reward_curriculum, params=params)
+  instance = reward_curriculum(cfg, env)
+  return instance(env, env_ids=torch.tensor([0, 1]), **params)
+
+
+def _build_termination(env, termination_name, stages):
+  params = {"termination_name": termination_name, "stages": stages}
+  cfg = CurriculumTermCfg(func=termination_curriculum, params=params)
+  instance = termination_curriculum(cfg, env)
+  return instance(env, env_ids=torch.tensor([0, 1]), **params)
+
+
+def _make_reward_env(step_counter, reward_cfg):
+  env = Mock()
+  env.common_step_counter = step_counter
+  env.reward_manager.get_term_cfg.return_value = reward_cfg
+  return env
+
+
+def _make_termination_env(step_counter, term_cfg):
+  env = Mock()
+  env.common_step_counter = step_counter
+  env.termination_manager.get_term_cfg.return_value = term_cfg
+  return env
+
+
+# Reward: weight
+
+
+def test_reward_weight_unchanged_before_threshold():
+  rc = _make_reward_cfg()
+  env = _make_reward_env(0, rc)
+  _build_reward(env, "r", [{"step": 100, "weight": 2.0}])
+  assert rc.weight == pytest.approx(1.0)
+
+
+def test_reward_weight_applied_at_threshold():
+  rc = _make_reward_cfg()
+  env = _make_reward_env(100, rc)
+  _build_reward(env, "r", [{"step": 100, "weight": 2.0}])
+  assert rc.weight == pytest.approx(2.0)
+
+
+def test_reward_weight_later_stage_wins():
+  rc = _make_reward_cfg()
+  env = _make_reward_env(500, rc)
+  _build_reward(
+    env,
+    "r",
+    [
+      {"step": 0, "weight": 0.5},
+      {"step": 100, "weight": 1.5},
+      {"step": 400, "weight": 3.0},
+    ],
+  )
+  assert rc.weight == pytest.approx(3.0)
+
+
+def test_reward_weight_partial_application():
+  rc = _make_reward_cfg()
+  env = _make_reward_env(150, rc)
+  _build_reward(
+    env,
+    "r",
+    [
+      {"step": 100, "weight": 2.0},
+      {"step": 200, "weight": 4.0},
+    ],
+  )
+  assert rc.weight == pytest.approx(2.0)
+
+
+def test_step_zero_applies_immediately():
+  rc = _make_reward_cfg()
+  env = _make_reward_env(0, rc)
+  _build_reward(env, "r", [{"step": 0, "weight": 9.0}])
+  assert rc.weight == pytest.approx(9.0)
+
+
+# Reward: params
+
+
+def test_reward_params_updated():
+  rc = _make_reward_cfg()
+  env = _make_reward_env(200, rc)
+  _build_reward(env, "r", [{"step": 100, "params": {"std": 0.2}}])
+  assert rc.params["std"] == 0.2
+
+
+def test_reward_params_unchanged_before_threshold():
+  rc = _make_reward_cfg()
+  env = _make_reward_env(0, rc)
+  _build_reward(env, "r", [{"step": 100, "params": {"std": 0.2}}])
+  assert rc.params["std"] == 0.5
+
+
+def test_reward_multiple_params_updated():
+  rc = _make_reward_cfg()
+  env = _make_reward_env(200, rc)
+  _build_reward(env, "r", [{"step": 100, "params": {"std": 0.2, "scale": 2.0}}])
+  assert rc.params["std"] == 0.2
+  assert rc.params["scale"] == 2.0
+
+
+# Reward: combined weight + params
+
+
+def test_reward_weight_and_params_in_same_stage():
+  rc = _make_reward_cfg()
+  env = _make_reward_env(200, rc)
+  _build_reward(env, "r", [{"step": 100, "weight": 5.0, "params": {"std": 0.1}}])
+  assert rc.weight == pytest.approx(5.0)
+  assert rc.params["std"] == 0.1
+
+
+# Termination: params
+
+
+def test_termination_params_updated():
+  tc = _make_termination_cfg()
+  env = _make_termination_env(200, tc)
+  _build_termination(env, "energy", [{"step": 100, "params": {"threshold": 500.0}}])
+  assert tc.params["threshold"] == 500.0
+
+
+def test_termination_params_unchanged_before_threshold():
+  tc = _make_termination_cfg()
+  env = _make_termination_env(0, tc)
+  _build_termination(env, "energy", [{"step": 100, "params": {"threshold": 500.0}}])
+  assert tc.params["threshold"] == float("inf")
+
+
+def test_termination_later_stage_wins():
+  tc = _make_termination_cfg()
+  env = _make_termination_env(500, tc)
+  _build_termination(
+    env,
+    "energy",
+    [
+      {"step": 0, "params": {"threshold": 1000.0}},
+      {"step": 100, "params": {"threshold": 700.0}},
+      {"step": 400, "params": {"threshold": 400.0}},
+    ],
+  )
+  assert tc.params["threshold"] == 400.0
+
+
+# Validation: shared engine
+
+
+def test_unknown_reward_param_raises():
+  rc = _make_reward_cfg()
+  env = _make_reward_env(0, rc)
+  params = {"reward_name": "r", "stages": [{"step": 0, "params": {"stdd": 0.2}}]}
+  cfg = CurriculumTermCfg(func=reward_curriculum, params=params)
+  with pytest.raises(KeyError, match="unknown param"):
+    reward_curriculum(cfg, env)
+
+
+def test_unknown_termination_param_raises():
+  tc = _make_termination_cfg()
+  env = _make_termination_env(0, tc)
+  params = {
+    "termination_name": "energy",
+    "stages": [{"step": 0, "params": {"thresholddd": 1.0}}],
+  }
+  cfg = CurriculumTermCfg(func=termination_curriculum, params=params)
+  with pytest.raises(KeyError, match="unknown param"):
+    termination_curriculum(cfg, env)
+
+
+def test_unsorted_stages_raise():
+  rc = _make_reward_cfg()
+  env = _make_reward_env(0, rc)
+  params = {
+    "reward_name": "r",
+    "stages": [
+      {"step": 200, "weight": 1.0},
+      {"step": 100, "weight": 2.0},
+    ],
+  }
+  cfg = CurriculumTermCfg(func=reward_curriculum, params=params)
+  with pytest.raises(ValueError, match="nondecreasing"):
+    reward_curriculum(cfg, env)
+
+
+def test_duplicate_steps_allowed():
+  rc = _make_reward_cfg()
+  env = _make_reward_env(200, rc)
+  _build_reward(
+    env,
+    "r",
+    [
+      {"step": 100, "weight": 2.0},
+      {"step": 100, "params": {"std": 0.1}},
+    ],
+  )
+  assert rc.weight == pytest.approx(2.0)
+  assert rc.params["std"] == 0.1
+
+
+# Logging keys
+
+
+def test_reward_logs_only_staged_keys():
+  rc = _make_reward_cfg()
+  env = _make_reward_env(200, rc)
+  result = _build_reward(
+    env, "r", [{"step": 100, "weight": 5.0, "params": {"std": 0.2}}]
+  )
+  assert result["weight"].item() == pytest.approx(5.0)
+  assert result["std"].item() == pytest.approx(0.2)
+  assert "scale" not in result  # Not in any stage.
+
+
+def test_reward_omits_weight_when_not_staged():
+  rc = _make_reward_cfg()
+  env = _make_reward_env(200, rc)
+  result = _build_reward(env, "r", [{"step": 100, "params": {"std": 0.2}}])
+  assert "weight" not in result
+  assert "std" in result
+
+
+def test_termination_log_keys():
+  tc = _make_termination_cfg()
+  env = _make_termination_env(200, tc)
+  result = _build_termination(
+    env, "energy", [{"step": 100, "params": {"threshold": 500.0}}]
+  )
+  assert "threshold" in result
+  assert result["threshold"].item() == pytest.approx(500.0)
+  assert "weight" not in result  # No weight for termination.
diff --git a/tests/test_events.py b/tests/test_events.py
new file mode 100644
index 0000000..4ce3fd5
--- /dev/null
+++ b/tests/test_events.py
@@ -0,0 +1,1063 @@
+"""Tests for EventManager, special dr.* functions, and recomputation."""
+
+from unittest.mock import Mock
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab import actuator
+from mjlab.entity import EntityCfg
+from mjlab.envs.mdp import dr, events
+from mjlab.managers.event_manager import (
+  EventManager,
+  EventTermCfg,
+  RecomputeLevel,
+)
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.scene import Scene, SceneCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+pytestmark = pytest.mark.filterwarnings(
+  "ignore:Use of index_put_ on expanded tensors is deprecated:UserWarning"
+)
+
+# ---------------------------------------------------------------------------
+# Shared helpers
+# ---------------------------------------------------------------------------
+
+ROBOT_XML = """
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="base_geom" type="box" size="0.1 0.1 0.1" mass="5.0"/>
+      <body name="link1" pos="0.2 0 0">
+        <joint name="joint1" type="hinge" axis="0 0 1" range="0 1.57"
+          armature="0.1"/>
+        <geom name="link1_geom" type="box" size="0.05 0.05 0.2" mass="1.0"/>
+      </body>
+      <body name="link2" pos="-0.2 0 0">
+        <joint name="joint2" type="hinge" axis="0 0 1" range="0 1.57"
+          armature="0.1"/>
+        <geom name="link2_geom" type="box" size="0.05 0.05 0.2" mass="1.0"/>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+NUM_ENVS = 2
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+class Env:
+  def __init__(self, scene, sim, device):
+    self.scene = scene
+    self.sim = sim
+    self.num_envs = scene.num_envs
+    self.device = device
+
+
+def create_env(device, fields, num_envs=NUM_ENVS):
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML))
+  scene_cfg = SceneCfg(num_envs=num_envs, entities={"robot": entity_cfg})
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+
+  sim = Simulation(num_envs=num_envs, cfg=SimulationCfg(), model=model, device=device)
+  scene.initialize(model, sim.model, sim.data)
+  sim.expand_model_fields(fields)
+
+  return Env(scene, sim, device)
+
+
+# ===========================================================================
+# Section 1: EventManager
+# ===========================================================================
+
+
+def test_dr_fields_registered_in_event_manager(device):
+  """@requires_model_fields functions populate manager.domain_randomization_fields."""
+  env = Mock()
+  env.num_envs = 4
+  env.device = device
+  env.scene = {}
+  env.sim = Mock()
+
+  cfg = {
+    "friction_dr": EventTermCfg(
+      mode="startup",
+      func=dr.geom_friction,
+      params={"ranges": (0.3, 1.2)},
+    ),
+    "damping_dr": EventTermCfg(
+      mode="reset",
+      func=dr.joint_damping,
+      params={"ranges": (0.1, 0.5)},
+    ),
+    "pd_gains": EventTermCfg(
+      mode="reset",
+      func=dr.pd_gains,
+      params={"kp_range": (0.8, 1.2), "kd_range": (0.8, 1.2)},
+    ),
+    "effort_limits": EventTermCfg(
+      mode="reset",
+      func=dr.effort_limits,
+      params={"effort_limit_range": (0.8, 1.2)},
+    ),
+    "regular_event": EventTermCfg(
+      mode="reset",
+      func=events.reset_joints_by_offset,
+      params={"position_range": (-0.1, 0.1), "velocity_range": (0.0, 0.0)},
+    ),
+  }
+
+  manager = EventManager(cfg, env)
+
+  assert "geom_friction" in manager.domain_randomization_fields
+  assert "dof_damping" in manager.domain_randomization_fields
+  assert "actuator_gainprm" in manager.domain_randomization_fields
+  assert "actuator_biasprm" in manager.domain_randomization_fields
+  assert "actuator_forcerange" in manager.domain_randomization_fields
+  assert "jnt_actfrcrange" in manager.domain_randomization_fields
+  assert "tendon_actfrcrange" in manager.domain_randomization_fields
+  assert len(manager.domain_randomization_fields) == 7
+
+
+def test_recompute_fields_registered_in_event_manager(device):
+  """Recomputed model fields are expanded per environment."""
+  env = Mock()
+  env.num_envs = 4
+  env.device = device
+  env.scene = {}
+  env.sim = Mock()
+
+  cfg = {
+    "body_com": EventTermCfg(
+      mode="startup",
+      func=dr.body_com_offset,
+      params={"ranges": (-0.01, 0.01)},
+    ),
+  }
+
+  manager = EventManager(cfg, env)
+
+  assert manager.domain_randomization_fields == (
+    "body_ipos",
+    "body_subtreemass",
+    "dof_invweight0",
+    "body_invweight0",
+    "tendon_length0",
+    "tendon_invweight0",
+    "actuator_acc0",
+  )
+
+
+def test_recompute_level_ordering():
+  """IntEnum max() gives strongest level."""
+  L = RecomputeLevel
+  assert max(L.none, L.set_const_0) == L.set_const_0
+  assert max(L.set_const_0, L.set_const) == L.set_const
+  assert max(L.set_const, L.set_const_fixed) == L.set_const
+  assert max(L.none, L.none) == L.none
+
+
+def test_recompute_not_called_when_no_dr_fired(device):
+  """Non-DR events don't trigger recompute."""
+  env = Mock()
+  env.num_envs = 2
+  env.device = device
+  env.scene = {}
+  env.sim = Mock()
+  env.sim.recompute_constants = Mock()
+
+  cfg = {
+    "regular_event": EventTermCfg(
+      mode="reset",
+      func=lambda env, env_ids: None,
+      params={},
+    ),
+  }
+
+  manager = EventManager(cfg, env)
+  manager.apply(
+    "reset",
+    env_ids=torch.tensor([0], device=device),
+    global_env_step_count=1,
+  )
+
+  env.sim.recompute_constants.assert_not_called()
+
+
+# ===========================================================================
+# Section 2: PD gains & effort limits
+# ===========================================================================
+
+
+def _make_pd_env(device, num_envs=2):
+  """Create a mock env with Builtin, Xml, and Ideal actuators for PD tests."""
+  env = Mock()
+  env.num_envs = num_envs
+  env.device = device
+
+  mock_entity = Mock()
+
+  builtin = Mock(spec=actuator.BuiltinPositionActuator)
+  builtin.ctrl_ids = torch.tensor([0, 1], device=device)
+  builtin.global_ctrl_ids = torch.tensor([0, 1], device=device)
+
+  xml = Mock(spec=actuator.XmlActuator)
+  xml.command_field = "position"
+  xml.ctrl_ids = torch.tensor([2, 3], device=device)
+  xml.global_ctrl_ids = torch.tensor([2, 3], device=device)
+
+  ideal = Mock(spec=actuator.IdealPdActuator)
+  ideal.ctrl_ids = torch.tensor([4, 5], device=device)
+  ideal.global_ctrl_ids = torch.tensor([4, 5], device=device)
+  ideal.stiffness = torch.tensor([[100.0, 100.0]] * num_envs, device=device)
+  ideal.damping = torch.tensor([[10.0, 10.0]] * num_envs, device=device)
+  ideal.default_stiffness = torch.tensor([[100.0, 100.0]] * num_envs, device=device)
+  ideal.default_damping = torch.tensor([[10.0, 10.0]] * num_envs, device=device)
+  ideal.set_gains = actuator.IdealPdActuator.set_gains.__get__(ideal)
+
+  mock_entity.actuators = [builtin, xml, ideal]
+  env.scene = {"robot": mock_entity}
+
+  env.sim = Mock()
+  env.sim.model = Mock()
+  env.sim.model.actuator_gainprm = torch.ones((num_envs, 6, 10), device=device) * 50.0
+  env.sim.model.actuator_biasprm = torch.zeros((num_envs, 6, 10), device=device)
+  env.sim.model.actuator_biasprm[:, :, 1] = -50.0
+  env.sim.model.actuator_biasprm[:, :, 2] = -5.0
+
+  default_gainprm = torch.ones((6, 10), device=device) * 50.0
+  default_biasprm = torch.zeros((6, 10), device=device)
+  default_biasprm[:, 1] = -50.0
+  default_biasprm[:, 2] = -5.0
+  defaults = {
+    "actuator_gainprm": default_gainprm,
+    "actuator_biasprm": default_biasprm,
+  }
+  env.sim.get_default_field = lambda f: defaults[f]
+
+  return env, ideal
+
+
+def _make_effort_env(device, num_envs=2):
+  """Create a mock env with Builtin, Xml, and Ideal actuators for effort tests."""
+  env = Mock()
+  env.num_envs = num_envs
+  env.device = device
+
+  mock_entity = Mock()
+
+  builtin = Mock(spec=actuator.BuiltinPositionActuator)
+  builtin.ctrl_ids = torch.tensor([0, 1], device=device)
+  builtin.global_ctrl_ids = torch.tensor([0, 1], device=device)
+
+  xml = Mock(spec=actuator.XmlActuator)
+  xml.command_field = "position"
+  xml.ctrl_ids = torch.tensor([2, 3], device=device)
+  xml.global_ctrl_ids = torch.tensor([2, 3], device=device)
+
+  ideal = Mock(spec=actuator.IdealPdActuator)
+  ideal.ctrl_ids = torch.tensor([4, 5], device=device)
+  ideal.global_ctrl_ids = torch.tensor([4, 5], device=device)
+  ideal.force_limit = torch.tensor([[50.0, 50.0]] * num_envs, device=device)
+  ideal.default_force_limit = torch.tensor([[50.0, 50.0]] * num_envs, device=device)
+  ideal.set_effort_limit = actuator.IdealPdActuator.set_effort_limit.__get__(ideal)
+
+  mock_entity.actuators = [builtin, xml, ideal]
+  env.scene = {"robot": mock_entity}
+
+  env.sim = Mock()
+  env.sim.model = Mock()
+  env.sim.model.actuator_forcerange = torch.zeros((num_envs, 6, 2), device=device)
+  env.sim.model.actuator_forcerange[:, :, 0] = -100.0
+  env.sim.model.actuator_forcerange[:, :, 1] = 100.0
+
+  default_forcerange = torch.zeros((6, 2), device=device)
+  default_forcerange[:, 0] = -100.0
+  default_forcerange[:, 1] = 100.0
+  env.sim.get_default_field = lambda field: default_forcerange
+
+  return env, ideal
+
+
+@pytest.mark.parametrize(
+  "operation, env_id, kp, kd, expected_gainprm, expected_biasprm_1,"
+  " expected_biasprm_2, expected_stiffness, expected_damping",
+  [
+    ("scale", 0, 1.5, 2.0, 75.0, -75.0, -10.0, 150.0, 20.0),
+    ("abs", 1, 200.0, 25.0, 200.0, -200.0, -25.0, 200.0, 25.0),
+  ],
+)
+def test_pd_gains(
+  device,
+  operation,
+  env_id,
+  kp,
+  kd,
+  expected_gainprm,
+  expected_biasprm_1,
+  expected_biasprm_2,
+  expected_stiffness,
+  expected_damping,
+):
+  """PD gains scale/abs on Builtin, Xml, and Ideal actuators."""
+  env, ideal = _make_pd_env(device)
+
+  dr.pd_gains(
+    env,
+    torch.tensor([env_id], device=device),
+    kp_range=(kp, kp),
+    kd_range=(kd, kd),
+    asset_cfg=SceneEntityCfg("robot"),
+    operation=operation,
+  )
+
+  d = device
+  # Builtin actuator.
+  assert torch.allclose(
+    env.sim.model.actuator_gainprm[env_id, [0, 1], 0],
+    torch.tensor([expected_gainprm] * 2, device=d),
+  )
+  assert torch.allclose(
+    env.sim.model.actuator_biasprm[env_id, [0, 1], 1],
+    torch.tensor([expected_biasprm_1] * 2, device=d),
+  )
+  assert torch.allclose(
+    env.sim.model.actuator_biasprm[env_id, [0, 1], 2],
+    torch.tensor([expected_biasprm_2] * 2, device=d),
+  )
+  # Xml actuator.
+  assert torch.allclose(
+    env.sim.model.actuator_gainprm[env_id, [2, 3], 0],
+    torch.tensor([expected_gainprm] * 2, device=d),
+  )
+  # Ideal actuator.
+  assert torch.allclose(
+    ideal.stiffness[env_id],
+    torch.tensor([expected_stiffness] * 2, device=d),
+  )
+  assert torch.allclose(
+    ideal.damping[env_id],
+    torch.tensor([expected_damping] * 2, device=d),
+  )
+
+
+def test_pd_gains_multi_env(device):
+  """Independent values per environment."""
+  env, _ = _make_pd_env(device)
+
+  torch.manual_seed(42)
+  dr.pd_gains(
+    env,
+    torch.tensor([0, 1], device=device),
+    kp_range=(0.5, 2.0),
+    kd_range=(0.5, 2.0),
+    asset_cfg=SceneEntityCfg("robot"),
+    operation="scale",
+  )
+
+  gains = env.sim.model.actuator_gainprm[:, :2, 0]
+  assert (gains != 50.0).all()
+  assert not torch.allclose(gains[0], gains[1])
+
+
+@pytest.mark.parametrize(
+  "operation, env_id, limit, expected_lower, expected_upper, expected_ideal",
+  [
+    ("scale", 0, 2.0, -200.0, 200.0, 100.0),
+    ("abs", 1, 150.0, -150.0, 150.0, 150.0),
+  ],
+)
+def test_effort_limits(
+  device, operation, env_id, limit, expected_lower, expected_upper, expected_ideal
+):
+  """Effort limits scale/abs on Builtin, Xml, and Ideal actuators."""
+  env, ideal = _make_effort_env(device)
+
+  dr.effort_limits(
+    env,
+    torch.tensor([env_id], device=device),
+    effort_limit_range=(limit, limit),
+    asset_cfg=SceneEntityCfg("robot"),
+    operation=operation,
+  )
+
+  d = device
+  # Builtin.
+  assert torch.allclose(
+    env.sim.model.actuator_forcerange[env_id, [0, 1], 0],
+    torch.tensor([expected_lower] * 2, device=d),
+  )
+  assert torch.allclose(
+    env.sim.model.actuator_forcerange[env_id, [0, 1], 1],
+    torch.tensor([expected_upper] * 2, device=d),
+  )
+  # Xml.
+  assert torch.allclose(
+    env.sim.model.actuator_forcerange[env_id, [2, 3], 0],
+    torch.tensor([expected_lower] * 2, device=d),
+  )
+  # Ideal.
+  assert torch.allclose(
+    ideal.force_limit[env_id],
+    torch.tensor([expected_ideal] * 2, device=d),
+  )
+
+
+def test_effort_limits_multi_env(device):
+  """Independent values per environment."""
+  env, _ = _make_effort_env(device)
+
+  torch.manual_seed(42)
+  dr.effort_limits(
+    env,
+    torch.tensor([0, 1], device=device),
+    effort_limit_range=(0.5, 2.0),
+    asset_cfg=SceneEntityCfg("robot"),
+    operation="scale",
+  )
+
+  upper = env.sim.model.actuator_forcerange[:, :2, 1]
+  assert (upper != 100.0).all()
+  assert not torch.allclose(upper[0], upper[1])
+
+
+def test_effort_limits_scale_no_accumulation(device):
+  """Scale operation uses defaults (no accumulation)."""
+  env, _ = _make_effort_env(device)
+
+  for _ in range(3):
+    dr.effort_limits(
+      env,
+      env_ids=None,
+      effort_limit_range=(2.0, 2.0),
+      asset_cfg=SceneEntityCfg("robot"),
+      operation="scale",
+    )
+
+  actual_upper = env.sim.model.actuator_forcerange[0, 0, 1].item()
+  assert abs(actual_upper - 200.0) < 1e-5
+
+
+def test_pd_gains_accepts_operation_object(device):
+  """dr.scale / dr.abs Operation objects produce the same result as strings."""
+  env_str, ideal_str = _make_pd_env(device)
+  env_obj, ideal_obj = _make_pd_env(device)
+
+  ids = torch.tensor([0], device=device)
+  kwargs = dict(
+    kp_range=(1.5, 1.5), kd_range=(2.0, 2.0), asset_cfg=SceneEntityCfg("robot")
+  )
+
+  torch.manual_seed(0)
+  dr.pd_gains(env_str, ids, operation="scale", **kwargs)
+  torch.manual_seed(0)
+  dr.pd_gains(env_obj, ids, operation=dr.scale, **kwargs)
+
+  assert torch.allclose(
+    env_str.sim.model.actuator_gainprm[0], env_obj.sim.model.actuator_gainprm[0]
+  )
+  assert torch.allclose(ideal_str.stiffness, ideal_obj.stiffness)
+
+
+def test_effort_limits_accepts_operation_object(device):
+  """dr.abs Operation object produces the same result as the string."""
+  env_str, ideal_str = _make_effort_env(device)
+  env_obj, ideal_obj = _make_effort_env(device)
+
+  ids = torch.tensor([0], device=device)
+  kwargs = dict(effort_limit_range=(150.0, 150.0), asset_cfg=SceneEntityCfg("robot"))
+
+  dr.effort_limits(env_str, ids, operation="abs", **kwargs)
+  dr.effort_limits(env_obj, ids, operation=dr.abs, **kwargs)
+
+  assert torch.allclose(
+    env_str.sim.model.actuator_forcerange[0], env_obj.sim.model.actuator_forcerange[0]
+  )
+  assert torch.allclose(ideal_str.force_limit, ideal_obj.force_limit)
+
+
+def test_pd_gains_rejects_unsupported_operation(device):
+  """Operations other than scale/abs raise ValueError."""
+  env, _ = _make_pd_env(device)
+  ids = torch.tensor([0], device=device)
+
+  with pytest.raises(ValueError, match="only supports 'scale' and 'abs'"):
+    dr.pd_gains(env, ids, kp_range=(1.0, 1.0), kd_range=(1.0, 1.0), operation=dr.add)
+
+
+def test_effort_limits_rejects_unsupported_operation(device):
+  """Operations other than scale/abs raise ValueError."""
+  env, _ = _make_effort_env(device)
+  ids = torch.tensor([0], device=device)
+
+  with pytest.raises(ValueError, match="only supports 'scale' and 'abs'"):
+    dr.effort_limits(env, ids, effort_limit_range=(1.0, 1.0), operation=dr.add)
+
+
+# ===========================================================================
+# Section 3: Other events
+# ===========================================================================
+
+
+def test_reset_joints_by_offset(device):
+  """reset_joints_by_offset applies offsets and respects joint limits."""
+  env = Mock()
+  env.num_envs = 2
+  env.device = device
+
+  mock_entity = Mock()
+  mock_entity.data.default_joint_pos = torch.zeros((2, 3), device=device)
+  mock_entity.data.default_joint_vel = torch.zeros((2, 3), device=device)
+  mock_entity.data.soft_joint_pos_limits = torch.tensor(
+    [
+      [[-0.5, 0.5], [-0.5, 0.5], [-0.5, 0.5]],
+      [[-0.5, 0.5], [-0.5, 0.5], [-0.5, 0.5]],
+    ],
+    device=device,
+  )
+  mock_entity.write_joint_state_to_sim = Mock()
+  env.scene = {"robot": mock_entity}
+
+  # Normal offset.
+  events.reset_joints_by_offset(
+    env,
+    torch.tensor([0], device=device),
+    position_range=(0.3, 0.3),
+    velocity_range=(0.2, 0.2),
+    asset_cfg=SceneEntityCfg("robot", joint_ids=slice(None)),
+  )
+
+  call_args = mock_entity.write_joint_state_to_sim.call_args
+  joint_pos, joint_vel = call_args[0][0], call_args[0][1]
+  assert torch.allclose(joint_pos, torch.ones_like(joint_pos) * 0.3)
+  assert torch.allclose(joint_vel, torch.ones_like(joint_vel) * 0.2)
+
+  # Clamping when offset exceeds limits.
+  events.reset_joints_by_offset(
+    env,
+    torch.tensor([1], device=device),
+    position_range=(1.0, 1.0),
+    velocity_range=(0.0, 0.0),
+    asset_cfg=SceneEntityCfg("robot", joint_ids=slice(None)),
+  )
+
+  call_args = mock_entity.write_joint_state_to_sim.call_args
+  joint_pos = call_args[0][0]
+  assert torch.allclose(joint_pos, torch.ones_like(joint_pos) * 0.5)
+
+
+# ===========================================================================
+# Section 4: Step mode and apply_body_impulse
+# ===========================================================================
+
+
+def test_step_mode_fires_every_call(device):
+  """Step-mode events fire unconditionally on every apply() call."""
+  call_count = [0]
+
+  def counter(env, env_ids):
+    call_count[0] += 1
+
+  env = Mock()
+  env.num_envs = 2
+  env.device = device
+  env.scene = {}
+  env.sim = Mock()
+
+  cfg = {
+    "step_counter": EventTermCfg(
+      mode="step",
+      func=counter,
+      params={},
+    ),
+  }
+  manager = EventManager(cfg, env)
+
+  for _ in range(5):
+    manager.apply(mode="step", dt=0.02)
+
+  assert call_count[0] == 5
+
+
+def _make_impulse_env(
+  device, num_envs=2, num_bodies=1, body_ids=None, cooldown_s=(0.0, 0.0)
+):
+  """Create a mock env for apply_body_impulse tests."""
+  if body_ids is None:
+    body_ids = [0]
+  env = Mock()
+  env.num_envs = num_envs
+  env.device = device
+  env.step_dt = 0.02
+
+  mock_entity = Mock()
+  mock_entity.num_bodies = num_bodies
+  mock_entity.data = Mock()
+  mock_entity.data.body_com_quat_w = torch.zeros(
+    (num_envs, num_bodies, 4), device=device
+  )
+  mock_entity.data.body_com_quat_w[..., 0] = 1.0
+  env.scene = {"robot": mock_entity}
+
+  asset_cfg = SceneEntityCfg("robot", body_ids=body_ids)
+  term_cfg = Mock()
+  term_cfg.params = {"asset_cfg": asset_cfg, "cooldown_s": cooldown_s}
+  impulse = events.apply_body_impulse(cfg=term_cfg, env=env)
+  return env, mock_entity, asset_cfg, impulse
+
+
+def test_apply_body_impulse_basic(device):
+  """Impulse is applied and cleared after duration expires."""
+  env, mock_entity, asset_cfg, impulse = _make_impulse_env(
+    device, num_envs=2, num_bodies=3, body_ids=[1], cooldown_s=(10.0, 10.0)
+  )
+
+  # Skip the initial cooldown so the first call triggers immediately;
+  # the trigger/sustain/expire cycle is what's under test here.
+  impulse._interval_time_left[:] = 0.0
+
+  impulse(
+    env,
+    None,
+    force_range=(10.0, 10.0),
+    torque_range=(0.0, 0.0),
+    duration_s=(0.05, 0.05),
+    cooldown_s=(10.0, 10.0),
+    asset_cfg=asset_cfg,
+  )
+  assert impulse._active.any()
+  mock_entity.write_external_wrench_to_sim.assert_called()
+
+  def step():
+    impulse(
+      env,
+      None,
+      force_range=(10.0, 10.0),
+      torque_range=(0.0, 0.0),
+      duration_s=(0.05, 0.05),
+      cooldown_s=(10.0, 10.0),
+      asset_cfg=asset_cfg,
+    )
+
+  # Step a few times (duration is 0.05s, step_dt is 0.02s).
+  mock_entity.write_external_wrench_to_sim.reset_mock()
+  step()  # t=0.02, remaining=0.03
+  assert impulse._active.all()
+
+  step()  # t=0.04, remaining=0.01
+  assert impulse._active.all()
+
+  step()  # t=0.06, remaining=-0.01 -> cleared
+  assert not impulse._active.any()
+
+  # Verify write_external_wrench_to_sim was called with zeros to clear.
+  clear_call = None
+  for call in mock_entity.write_external_wrench_to_sim.call_args_list:
+    forces = call[0][0]
+    if torch.all(forces == 0):
+      clear_call = call
+  assert clear_call is not None
+
+
+def test_apply_body_impulse_with_offset(device):
+  """body_point_offset adds cross-product contribution to torque."""
+  env, mock_entity, asset_cfg, impulse = _make_impulse_env(
+    device, num_envs=1, num_bodies=1, body_ids=[0]
+  )
+
+  impulse(
+    env,
+    None,
+    force_range=(1.0, 1.0),
+    torque_range=(0.0, 0.0),
+    duration_s=(1.0, 1.0),
+    cooldown_s=(0.0, 0.0),
+    asset_cfg=asset_cfg,
+    body_point_offset=(0.0, 0.0, 0.5),
+  )
+
+  call_args = mock_entity.write_external_wrench_to_sim.call_args
+  forces = call_args[0][0]
+  torques = call_args[0][1]
+
+  # force is (1,1,1) applied at offset (0,0,0.5).
+  # cross((0,0,0.5), (1,1,1)) = (-0.5, 0.5, 0)
+  offset = torch.tensor([0.0, 0.0, 0.5], device=device)
+  expected_extra_torque = torch.cross(offset.unsqueeze(0), forces.squeeze(0), dim=-1)
+  torch.testing.assert_close(
+    torques.squeeze(0), expected_extra_torque, atol=1e-5, rtol=1e-5
+  )
+
+
+def test_apply_body_impulse_reset_clears(device):
+  """reset() zeros forces and resets internal state."""
+  env, mock_entity, asset_cfg, impulse = _make_impulse_env(
+    device, num_envs=2, num_bodies=1, body_ids=[0]
+  )
+
+  # Trigger impulse.
+  impulse(
+    env,
+    None,
+    force_range=(10.0, 10.0),
+    torque_range=(0.0, 0.0),
+    duration_s=(1.0, 1.0),
+    cooldown_s=(0.0, 0.0),
+    asset_cfg=asset_cfg,
+  )
+  assert impulse._active.all()
+
+  # Reset env 0.
+  mock_entity.write_external_wrench_to_sim.reset_mock()
+  impulse.reset(env_ids=torch.tensor([0], device=device))
+
+  assert not impulse._active[0]
+  assert impulse._active[1]
+  assert impulse._time_remaining[0] == 0.0
+
+  # Verify clearing write was called for env 0.
+  mock_entity.write_external_wrench_to_sim.assert_called_once()
+  call_args = mock_entity.write_external_wrench_to_sim.call_args
+  env_ids_arg = call_args[1]["env_ids"]
+  assert len(env_ids_arg) == 1
+  assert env_ids_arg[0].item() == 0
+
+
+def test_apply_body_impulse_initial_cooldown(device):
+  """The first call after init/reset enters cooldown, not an immediate impulse.
+
+  Regression test for #973.
+  """
+  env, mock_entity, asset_cfg, impulse = _make_impulse_env(
+    device, num_envs=1, num_bodies=1, body_ids=[0], cooldown_s=(0.05, 0.05)
+  )
+
+  def step():
+    impulse(
+      env,
+      None,
+      force_range=(10.0, 10.0),
+      torque_range=(0.0, 0.0),
+      duration_s=(1.0, 1.0),
+      cooldown_s=(0.05, 0.05),  # ~2.5 steps at dt=0.02
+      asset_cfg=asset_cfg,
+    )
+
+  # First two steps consume the sampled cooldown; impulse must not fire yet.
+  step()
+  assert not impulse._active.any()
+  step()
+  assert not impulse._active.any()
+
+  # Third step crosses the cooldown boundary and triggers.
+  step()
+  assert impulse._active.all()
+
+  # Reset re-enters cooldown: next step should not immediately re-trigger.
+  impulse.reset(env_ids=torch.tensor([0], device=device))
+  assert not impulse._active.any()
+  step()
+  assert not impulse._active.any()
+
+
+# ===========================================================================
+# Section 5: Recomputation integration
+# ===========================================================================
+
+
+def test_body_mass_recompute_subtreemass(device):
+  """body_subtreemass is correctly recomputed after body_mass change."""
+  env = create_env(device, ("body_mass", "body_subtreemass"))
+  robot = env.scene["robot"]
+  body_ids = robot.indexing.body_ids
+
+  original_subtreemass = env.sim.model.body_subtreemass[:, body_ids].clone()
+
+  env.sim.model.body_mass[0, body_ids] *= 2.0
+  env.sim.recompute_constants(RecomputeLevel.set_const)
+
+  new_subtreemass = env.sim.model.body_subtreemass[:, body_ids]
+
+  assert not torch.allclose(new_subtreemass[0], original_subtreemass[0])
+  torch.testing.assert_close(new_subtreemass[1], original_subtreemass[1])
+
+
+def test_body_mass_recompute_invweight(device):
+  """dof_invweight0 changes after body_mass modification."""
+  env = create_env(
+    device,
+    ("body_mass", "body_subtreemass", "dof_invweight0", "body_invweight0"),
+  )
+  robot = env.scene["robot"]
+  body_ids = robot.indexing.body_ids
+  dof_adr = robot.indexing.joint_v_adr
+
+  original_invweight = env.sim.model.dof_invweight0[:, dof_adr].clone()
+
+  env.sim.model.body_mass[0, body_ids] *= 2.0
+  env.sim.recompute_constants(RecomputeLevel.set_const)
+
+  new_invweight = env.sim.model.dof_invweight0[:, dof_adr]
+
+  assert not torch.allclose(new_invweight[0], original_invweight[0])
+  torch.testing.assert_close(new_invweight[1], original_invweight[1])
+
+
+def test_body_com_offset_recompute(device):
+  """body_ipos modification triggers correct recomputation."""
+  env = create_env(
+    device,
+    ("body_ipos", "body_subtreemass", "dof_invweight0", "body_invweight0"),
+  )
+  robot = env.scene["robot"]
+  body_ids = robot.indexing.body_ids
+  dof_adr = robot.indexing.joint_v_adr
+
+  original_invweight = env.sim.model.dof_invweight0[:, dof_adr].clone()
+
+  link1_idx = body_ids[1]
+  env.sim.model.body_ipos[0, link1_idx, 0] += 0.05
+  env.sim.recompute_constants(RecomputeLevel.set_const)
+
+  new_invweight = env.sim.model.dof_invweight0[:, dof_adr]
+
+  assert not torch.allclose(new_invweight[0], original_invweight[0])
+  torch.testing.assert_close(new_invweight[1], original_invweight[1])
+
+
+def test_dof_armature_recompute(device):
+  """dof_armature modification updates dof_invweight0."""
+  env = create_env(
+    device,
+    (
+      "dof_armature",
+      "dof_invweight0",
+      "body_invweight0",
+      "tendon_length0",
+      "tendon_invweight0",
+    ),
+  )
+  robot = env.scene["robot"]
+  dof_adr = robot.indexing.joint_v_adr
+
+  original_invweight = env.sim.model.dof_invweight0[:, dof_adr].clone()
+
+  env.sim.model.dof_armature[0, dof_adr] *= 10.0
+  env.sim.recompute_constants(RecomputeLevel.set_const_0)
+
+  new_invweight = env.sim.model.dof_invweight0[:, dof_adr]
+
+  assert not torch.allclose(new_invweight[0], original_invweight[0])
+  torch.testing.assert_close(new_invweight[1], original_invweight[1])
+
+
+# ===========================================================================
+# Section 6: Recompute vs mj_setConst / recompiled MjSpec
+# ===========================================================================
+
+
+def test_body_mass_recompute_matches_set_const(device):
+  """Modify body_mass: GPU recompute matches CPU mj_setConst."""
+  gpu_model = mujoco.MjModel.from_xml_string(ROBOT_XML)
+  cpu_model = mujoco.MjModel.from_xml_string(ROBOT_XML)
+
+  link1_id = mujoco.mj_name2id(cpu_model, mujoco.mjtObj.mjOBJ_BODY, "link1")
+
+  # GPU path.
+  expand_fields = (
+    "body_mass",
+    "body_subtreemass",
+    "dof_invweight0",
+    "body_invweight0",
+  )
+  sim = Simulation(num_envs=1, cfg=SimulationCfg(), model=gpu_model, device=device)
+  sim.expand_model_fields(expand_fields)
+  sim.model.body_mass[0, link1_id] = 5.0
+  sim.recompute_constants(RecomputeLevel.set_const)
+
+  # CPU ground truth: apply same cfg mutations as Simulation.__init__.
+  SimulationCfg().mujoco.apply(cpu_model)
+  cpu_data = mujoco.MjData(cpu_model)
+  mujoco.mj_forward(cpu_model, cpu_data)
+  cpu_model.body_mass[link1_id] = 5.0
+  mujoco.mj_setConst(cpu_model, cpu_data)
+
+  for field in ("body_subtreemass", "dof_invweight0", "body_invweight0"):
+    gpu_val = getattr(sim.model, field)[0].cpu()
+    ref_val = torch.tensor(getattr(cpu_model, field), dtype=torch.float32)
+    torch.testing.assert_close(gpu_val, ref_val, atol=1e-4, rtol=1e-4)
+
+
+def test_body_ipos_recompute_matches_set_const(device):
+  """Modify body_ipos: GPU recompute matches CPU mj_setConst."""
+  gpu_model = mujoco.MjModel.from_xml_string(ROBOT_XML)
+  cpu_model = mujoco.MjModel.from_xml_string(ROBOT_XML)
+
+  link1_id = mujoco.mj_name2id(cpu_model, mujoco.mjtObj.mjOBJ_BODY, "link1")
+
+  # GPU path.
+  expand_fields = (
+    "body_ipos",
+    "body_subtreemass",
+    "dof_invweight0",
+    "body_invweight0",
+  )
+  sim = Simulation(num_envs=1, cfg=SimulationCfg(), model=gpu_model, device=device)
+  sim.expand_model_fields(expand_fields)
+  sim.model.body_ipos[0, link1_id, 0] += 0.05
+  sim.recompute_constants(RecomputeLevel.set_const)
+
+  # CPU ground truth: apply same cfg mutations as Simulation.__init__.
+  SimulationCfg().mujoco.apply(cpu_model)
+  cpu_data = mujoco.MjData(cpu_model)
+  mujoco.mj_forward(cpu_model, cpu_data)
+  cpu_model.body_ipos[link1_id, 0] += 0.05
+  # Clear body_sameframe so mj_kinematics recomputes xipos from body_ipos.
+  # (When sameframe != 0, mj_local2Global skips the ipos→xipos transform.)
+  cpu_model.body_sameframe[link1_id] = 0
+  mujoco.mj_setConst(cpu_model, cpu_data)
+
+  for field in ("dof_invweight0", "body_invweight0"):
+    gpu_val = getattr(sim.model, field)[0].cpu()
+    ref_val = torch.tensor(getattr(cpu_model, field), dtype=torch.float32)
+    torch.testing.assert_close(gpu_val, ref_val, atol=1e-4, rtol=1e-4)
+
+
+def test_dof_armature_recompute_matches_recompile(device):
+  """Modify dof_armature: GPU recompute matches fresh MjSpec.compile()."""
+  spec = mujoco.MjSpec.from_string(ROBOT_XML)
+  original_model = spec.compile()
+
+  joint1_id = mujoco.mj_name2id(original_model, mujoco.mjtObj.mjOBJ_JOINT, "joint1")
+
+  # Ground truth: modify spec armature, recompile.
+  spec.joint("joint1").armature = 1.0
+  recompiled_model = spec.compile()
+
+  # GPU path.
+  expand_fields = (
+    "dof_armature",
+    "dof_invweight0",
+    "body_invweight0",
+    "tendon_length0",
+    "tendon_invweight0",
+  )
+  sim = Simulation(num_envs=1, cfg=SimulationCfg(), model=original_model, device=device)
+  sim.expand_model_fields(expand_fields)
+
+  dof_adr = original_model.jnt_dofadr[joint1_id]
+  sim.model.dof_armature[0, dof_adr] = 1.0
+  sim.recompute_constants(RecomputeLevel.set_const_0)
+
+  gpu_dof_invweight = sim.model.dof_invweight0[0].cpu()
+  ref_dof_invweight = torch.tensor(recompiled_model.dof_invweight0, dtype=torch.float32)
+  torch.testing.assert_close(gpu_dof_invweight, ref_dof_invweight, atol=1e-4, rtol=1e-4)
+
+
+# ===========================================================================
+# Section: interval timer reset (issue: reset iterated the class-only list)
+# ===========================================================================
+
+
+def _noop_interval_event(env, env_ids):
+  del env, env_ids
+
+
+class _ClassIntervalEvent:
+  """Class-based interval event with a reset hook."""
+
+  def __init__(self, cfg, env):
+    del cfg, env
+
+  def reset(self, env_ids=None):
+    del env_ids
+
+  def __call__(self, env, env_ids):
+    del env, env_ids
+
+
+def _make_mock_env(device, num_envs=4):
+  env = Mock()
+  env.num_envs = num_envs
+  env.device = device
+  env.scene = {}
+  env.sim = Mock()
+  return env
+
+
+def test_interval_timer_resets_for_function_terms(device):
+  """Function-based interval terms get their per-env timer resampled on reset."""
+  env = _make_mock_env(device)
+  cfg = {
+    "push": EventTermCfg(
+      mode="interval", func=_noop_interval_event, interval_range_s=(5.0, 10.0)
+    ),
+  }
+  manager = EventManager(cfg, env)
+
+  timer = manager._interval_term_time_left[0]
+  # Zero the reset env's timer so the in-range assertion below can only pass
+  # if reset actually resampled it (deterministic, not clone-and-compare).
+  timer[1] = 0.0
+  before = timer.clone()
+  reset_ids = torch.tensor([1], dtype=torch.int64, device=device)
+  manager.reset(env_ids=reset_ids)
+
+  assert 5.0 <= timer[1].item() <= 10.0
+  untouched = torch.tensor([0, 2, 3], device=device)
+  assert torch.equal(timer[untouched], before[untouched])
+
+
+def test_interval_timer_reset_with_mixed_terms(device):
+  """Mixed function and class interval terms reset the right timer slots."""
+  env = _make_mock_env(device)
+  cfg = {
+    "push": EventTermCfg(
+      mode="interval", func=_noop_interval_event, interval_range_s=(5.0, 10.0)
+    ),
+    "impulse": EventTermCfg(
+      mode="interval", func=_ClassIntervalEvent, interval_range_s=(100.0, 200.0)
+    ),
+  }
+  manager = EventManager(cfg, env)
+
+  push_timer = manager._interval_term_time_left[0]
+  impulse_timer = manager._interval_term_time_left[1]
+  # Zero both timers for the reset env so the in-range assertions can only
+  # pass if reset resampled each slot (the init draw is from the same range,
+  # so comparing against it would be vacuous).
+  push_timer[1] = 0.0
+  impulse_timer[1] = 0.0
+  reset_ids = torch.tensor([1], dtype=torch.int64, device=device)
+  manager.reset(env_ids=reset_ids)
+
+  # Each timer slot is resampled from its own term's range.
+  assert 5.0 <= push_timer[1].item() <= 10.0
+  assert 100.0 <= impulse_timer[1].item() <= 200.0
+
+
+def test_interval_timer_reset_all_envs(device):
+  """reset(env_ids=None) resamples every env's timer."""
+  env = _make_mock_env(device)
+  cfg = {
+    "push": EventTermCfg(
+      mode="interval", func=_noop_interval_event, interval_range_s=(5.0, 10.0)
+    ),
+  }
+  manager = EventManager(cfg, env)
+
+  timer = manager._interval_term_time_left[0]
+  timer[:] = 0.0
+  manager.reset(env_ids=None)
+  assert ((timer >= 5.0) & (timer <= 10.0)).all()
diff --git a/tests/test_flat_patch_sampling.py b/tests/test_flat_patch_sampling.py
new file mode 100644
index 0000000..95f5dec
--- /dev/null
+++ b/tests/test_flat_patch_sampling.py
@@ -0,0 +1,159 @@
+"""Tests for flat patch sampling on heightfield terrains."""
+
+import numpy as np
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.terrains.heightfield_terrains import HfRandomUniformTerrainCfg
+from mjlab.terrains.terrain_entity import TerrainEntity, TerrainEntityCfg
+from mjlab.terrains.terrain_generator import (
+  FlatPatchSamplingCfg,
+  TerrainGeneratorCfg,
+)
+from mjlab.terrains.utils import find_flat_patches_from_heightfield
+
+
+@pytest.fixture
+def rng() -> np.random.Generator:
+  return np.random.default_rng(42)
+
+
+def test_patches_avoid_step_boundary(rng: np.random.Generator):
+  """Patches must not land near a sharp height discontinuity."""
+  heights = np.zeros((80, 80), dtype=np.float64)
+  # Step along column axis → appears on MuJoCo x-axis.
+  heights[:, 40:] = 1.0
+  patch_radius = 0.3
+  cfg = FlatPatchSamplingCfg(
+    num_patches=50, patch_radius=patch_radius, max_height_diff=0.05
+  )
+  patches = find_flat_patches_from_heightfield(
+    heights=heights, horizontal_scale=0.1, z_offset=0.0, cfg=cfg, rng=rng
+  )
+  assert patches.shape == (50, 3)
+  for i in range(len(patches)):
+    x, z = patches[i, 0], patches[i, 2]
+    # Step is at x=4.0; no patch center should be within patch_radius of it.
+    assert x < 3.7 or x >= 4.3, f"Patch {i} at x={x:.2f} too close to step"
+    # z must be consistent with the side the patch landed on.
+    if x < 3.7:
+      assert abs(z) < 0.1, f"Low-x patch should have z~0, got {z}"
+    else:
+      assert abs(z - 1.0) < 0.1, f"High-x patch should have z~1, got {z}"
+
+
+def test_range_constraints(rng: np.random.Generator):
+  """x/y range filters restrict where patches can land."""
+  heights = np.zeros((80, 80), dtype=np.float64)
+  cfg = FlatPatchSamplingCfg(
+    num_patches=10,
+    patch_radius=0.3,
+    max_height_diff=0.1,
+    x_range=(2.0, 6.0),
+    y_range=(2.0, 6.0),
+  )
+  patches = find_flat_patches_from_heightfield(
+    heights=heights, horizontal_scale=0.1, z_offset=0.0, cfg=cfg, rng=rng
+  )
+  assert np.all(patches[:, 0] >= 2.0) and np.all(patches[:, 0] <= 6.0)
+  assert np.all(patches[:, 1] >= 2.0) and np.all(patches[:, 1] <= 6.0)
+
+
+def test_fallback_when_no_valid_patches(rng: np.random.Generator):
+  """When nothing is flat, all patches fall back to the terrain center."""
+  # Linear ramp along rows — every footprint spans a large height range.
+  heights = np.arange(80).reshape(80, 1).repeat(80, axis=1).astype(np.float64)
+  cfg = FlatPatchSamplingCfg(num_patches=5, patch_radius=0.3, max_height_diff=0.001)
+  patches = find_flat_patches_from_heightfield(
+    heights=heights, horizontal_scale=0.1, z_offset=0.0, cfg=cfg, rng=rng
+  )
+  center_x = 80 * 0.1 / 2.0
+  center_y = 80 * 0.1 / 2.0
+  np.testing.assert_allclose(patches[:, 0], center_x)
+  np.testing.assert_allclose(patches[:, 1], center_y)
+
+
+def test_patches_respect_edge_margin(rng: np.random.Generator):
+  """No patch center should be within patch_radius of the heightfield edge."""
+  heights = np.zeros((80, 80), dtype=np.float64)
+  patch_radius = 0.5
+  h_scale = 0.1
+  cfg = FlatPatchSamplingCfg(
+    num_patches=200, patch_radius=patch_radius, max_height_diff=0.1
+  )
+  patches = find_flat_patches_from_heightfield(
+    heights=heights, horizontal_scale=h_scale, z_offset=0.0, cfg=cfg, rng=rng
+  )
+  terrain_x = 80 * h_scale
+  terrain_y = 80 * h_scale
+  margin = patch_radius
+  # Every patch center must be at least patch_radius from each edge.
+  assert np.all(patches[:, 0] >= margin - h_scale)
+  assert np.all(patches[:, 0] <= terrain_x - margin + h_scale)
+  assert np.all(patches[:, 1] >= margin - h_scale)
+  assert np.all(patches[:, 1] <= terrain_y - margin + h_scale)
+
+
+def test_grid_resolution(rng: np.random.Generator):
+  """Finer grid_resolution still produces correct flat patches on a step."""
+  heights = np.zeros((80, 80), dtype=np.float64)
+  heights[:, 40:] = 1.0
+  cfg = FlatPatchSamplingCfg(
+    num_patches=30,
+    patch_radius=0.3,
+    max_height_diff=0.05,
+    grid_resolution=0.025,
+  )
+  patches = find_flat_patches_from_heightfield(
+    heights=heights, horizontal_scale=0.1, z_offset=0.0, cfg=cfg, rng=rng
+  )
+  assert patches.shape == (30, 3)
+  for i in range(len(patches)):
+    x, z = patches[i, 0], patches[i, 2]
+    assert x < 3.7 or x >= 4.3, f"Patch {i} at x={x:.2f} too close to step"
+    if x < 3.7:
+      assert abs(z) < 0.1
+    else:
+      assert abs(z - 1.0) < 0.1
+
+
+def test_terrain_importer_end_to_end():
+  """Flat patches flow through generator → importer with correct shape and bounds."""
+  device = get_test_device()
+  terrain_size = (4.0, 4.0)
+  num_patches = 5
+  patch_cfg = FlatPatchSamplingCfg(
+    num_patches=num_patches, patch_radius=0.3, max_height_diff=0.1
+  )
+  gen_cfg = TerrainGeneratorCfg(
+    seed=123,
+    size=terrain_size,
+    num_rows=2,
+    num_cols=2,
+    sub_terrains={
+      "rough": HfRandomUniformTerrainCfg(
+        proportion=1.0,
+        noise_range=(0.02, 0.08),
+        noise_step=0.01,
+        flat_patch_sampling={"spawn": patch_cfg},
+      ),
+    },
+  )
+  importer_cfg = TerrainEntityCfg(
+    terrain_type="generator", terrain_generator=gen_cfg, num_envs=4
+  )
+  importer = TerrainEntity(importer_cfg, device=device)
+
+  assert "spawn" in importer.flat_patches
+  patches = importer.flat_patches["spawn"]
+  assert patches.shape == (2, 2, num_patches, 3)
+  assert patches.dtype == torch.float
+
+  # Every patch should be within the world-space extent of the full terrain grid.
+  # Grid is centered at origin → spans [-total/2, +total/2].
+  half_x = gen_cfg.num_rows * terrain_size[0] / 2
+  half_y = gen_cfg.num_cols * terrain_size[1] / 2
+  pts = patches.cpu().numpy().reshape(-1, 3)
+  assert np.all(pts[:, 0] >= -half_x) and np.all(pts[:, 0] <= half_x)
+  assert np.all(pts[:, 1] >= -half_y) and np.all(pts[:, 1] <= half_y)
diff --git a/tests/test_foot_height_sensor.py b/tests/test_foot_height_sensor.py
new file mode 100644
index 0000000..884bf9f
--- /dev/null
+++ b/tests/test_foot_height_sensor.py
@@ -0,0 +1,230 @@
+"""Tests for per-foot height sensor and terrain-aware rewards."""
+
+from __future__ import annotations
+
+import pytest
+import torch
+from conftest import get_test_device, make_scene_and_sim
+
+from mjlab.sensor import ObjRef, RingPatternCfg, TerrainHeightSensorCfg
+from mjlab.sensor.terrain_height_sensor import TerrainHeightSensor
+
+# Platform top at z=0.5 (box center z=0.25, half-height 0.25).
+# Body at z=1.0, left_foot at z=0.8 (offset -0.2), right_foot at z=0.6 (offset -0.4).
+# Expected: left 0.3m above platform, right 0.1m above platform.
+# Both within max_distance=1.0.
+TWO_FEET_ABOVE_PLATFORM_XML = """
+  <mujoco>
+    <worldbody>
+      <geom name="platform" type="box" size="5 5 0.25" pos="0 0 0.25"/>
+      <body name="base" pos="0 0 1">
+        <freejoint name="free_joint"/>
+        <geom name="base_geom" type="sphere" size="0.05" mass="1.0"/>
+        <site name="left_foot" pos="-0.1 0 -0.2"/>
+        <site name="right_foot" pos="0.1 0 -0.4"/>
+      </body>
+    </worldbody>
+  </mujoco>
+"""
+
+# Stepped terrain: step top at z=0.4 for x<0, ground at z=0 for x>0.
+# Body at x=0, z=0.8. left_foot at x=-0.5 (over step), right_foot at x=0.5 (over ground).
+# Expected: left 0.4m above step, right 0.8m above ground.
+STEPPED_TERRAIN_XML = """
+  <mujoco>
+    <worldbody>
+      <geom name="ground" type="plane" size="5 5 0.1" pos="0 0 0"/>
+      <geom name="step" type="box" size="5 5 0.2" pos="-5 0 0.2"/>
+      <body name="base" pos="0 0 0.8">
+        <freejoint name="free_joint"/>
+        <geom name="base_geom" type="sphere" size="0.05" mass="1.0"/>
+        <site name="left_foot" pos="-0.5 0 0"/>
+        <site name="right_foot" pos="0.5 0 0"/>
+      </body>
+    </worldbody>
+  </mujoco>
+"""
+
+
+def _foot_sensor_cfg() -> TerrainHeightSensorCfg:
+  """Match the shipped config: yaw alignment, max_distance=1.0, group 0."""
+  return TerrainHeightSensorCfg(
+    name="foot_height_scan",
+    frame=(
+      ObjRef(type="site", name="left_foot", entity="robot"),
+      ObjRef(type="site", name="right_foot", entity="robot"),
+    ),
+    ray_alignment="yaw",
+    pattern=RingPatternCfg.single_ring(radius=0.04, num_samples=4),
+    max_distance=1.0,
+    exclude_parent_body=True,
+    include_geom_groups=(0,),
+  )
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+class _FakeEnv:
+  def __init__(self, scene):
+    self.scene = scene
+
+
+def test_foot_height_flat_platform(device):
+  """Two feet at different heights above a flat platform."""
+  cfg = _foot_sensor_cfg()
+  scene, sim = make_scene_and_sim(device, TWO_FEET_ABOVE_PLATFORM_XML, (cfg,))
+  sim.step()
+  sim.sense()
+
+  sensor: TerrainHeightSensor = scene["foot_height_scan"]
+  heights = sensor.data.heights
+
+  assert heights.shape == (1, 2)
+  # Left foot: z=0.8, platform top at z=0.5, height = 0.3.
+  assert heights[0, 0].item() == pytest.approx(0.3, abs=0.05)
+  # Right foot: z=0.6, platform top at z=0.5, height = 0.1.
+  assert heights[0, 1].item() == pytest.approx(0.1, abs=0.05)
+
+
+def test_foot_height_stepped_terrain(device):
+  """Feet over different terrain heights give different readings."""
+  cfg = _foot_sensor_cfg()
+  scene, sim = make_scene_and_sim(device, STEPPED_TERRAIN_XML, (cfg,))
+  sim.step()
+  sim.sense()
+
+  sensor: TerrainHeightSensor = scene["foot_height_scan"]
+  heights = sensor.data.heights
+
+  assert heights.shape == (1, 2)
+  # Left foot at x=-0.5, z=0.8, over step top at z=0.4 -> height ~0.4.
+  assert heights[0, 0].item() == pytest.approx(0.4, abs=0.1)
+  # Right foot at x=0.5, z=0.8, over ground at z=0 -> height ~0.8.
+  assert heights[0, 1].item() == pytest.approx(0.8, abs=0.1)
+
+
+def test_foot_height_observation(device):
+  """foot_height observation delegates to sensor.data.heights."""
+  from mjlab.tasks.velocity.mdp.observations import foot_height
+
+  cfg = _foot_sensor_cfg()
+  scene, sim = make_scene_and_sim(device, TWO_FEET_ABOVE_PLATFORM_XML, (cfg,))
+  sim.step()
+  sim.sense()
+
+  env = _FakeEnv(scene)
+  obs = foot_height(env, "foot_height_scan")  # type: ignore[invalid-argument-type]
+  sensor: TerrainHeightSensor = scene["foot_height_scan"]
+  direct = sensor.data.heights
+
+  assert torch.allclose(obs, direct)
+
+
+def test_foot_height_multi_env(device):
+  """Sensor works correctly across multiple environments."""
+  cfg = _foot_sensor_cfg()
+  scene, sim = make_scene_and_sim(
+    device, TWO_FEET_ABOVE_PLATFORM_XML, (cfg,), num_envs=4
+  )
+  sim.step()
+  sim.sense()
+
+  sensor: TerrainHeightSensor = scene["foot_height_scan"]
+  heights = sensor.data.heights
+
+  assert heights.shape == (4, 2)
+  # All envs should report same heights (identical geometry).
+  for i in range(4):
+    assert heights[i, 0].item() == pytest.approx(0.3, abs=0.05)
+    assert heights[i, 1].item() == pytest.approx(0.1, abs=0.05)
+
+
+def test_foot_height_miss_returns_max_distance(device):
+  """Feet beyond max_distance report max_distance, not -1."""
+  # Body at z=3 with feet at z=2.8 and z=2.6.
+  # max_distance=1.0, ground at z=0, so both feet are >1m above ground.
+  miss_xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="5 5 0.1" pos="0 0 0"/>
+        <body name="base" pos="0 0 3">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.05" mass="1.0"/>
+          <site name="left_foot" pos="-0.1 0 -0.2"/>
+          <site name="right_foot" pos="0.1 0 -0.4"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+  cfg = _foot_sensor_cfg()
+  scene, sim = make_scene_and_sim(device, miss_xml, (cfg,))
+  sim.step()
+  sim.sense()
+
+  sensor: TerrainHeightSensor = scene["foot_height_scan"]
+  heights = sensor.data.heights
+
+  # Both feet are >1m above ground, beyond max_distance=1.0.
+  assert heights[0, 0].item() == pytest.approx(1.0, abs=0.01)
+  assert heights[0, 1].item() == pytest.approx(1.0, abs=0.01)
+
+
+def test_foot_penetration_plane(device):
+  """Foot below a ground plane should report near-zero, not max_distance."""
+  xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="ground" type="plane" size="5 5 0.1" pos="0 0 0"/>
+        <body name="base" pos="0 0 0.05">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.02" mass="1.0" group="1"/>
+          <site name="left_foot" pos="0 0 -0.04"/>
+          <site name="right_foot" pos="0 0 -0.06"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+  # left_foot at z=0.01 (above), right_foot at z=-0.01 (below).
+  cfg = _foot_sensor_cfg()
+  scene, sim = make_scene_and_sim(device, xml, (cfg,))
+  sim.step()
+  sim.forward()
+  sim.sense()
+
+  heights = scene["foot_height_scan"].data.heights[0]
+  assert heights[0].item() < 0.1
+  assert heights[1].item() < 0.5
+
+
+def test_foot_penetration_box(device):
+  """Foot inside box terrain should report near-zero, not box thickness.
+
+  Regression: rays inside a box hit the bottom face, producing a bogus
+  height equal to the box thickness.
+  """
+  xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="terrain" type="box" size="5 5 0.5" pos="0 0 0.5"/>
+        <body name="base" pos="0 0 1.05">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.02" mass="1.0" group="1"/>
+          <site name="left_foot" pos="0 0 -0.04"/>
+          <site name="right_foot" pos="0 0 -0.08"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+  # Terrain top at z=1.0. left_foot at z=1.01, right_foot at z=0.97.
+  cfg = _foot_sensor_cfg()
+  scene, sim = make_scene_and_sim(device, xml, (cfg,))
+  sim.step()
+  sim.forward()
+  sim.sense()
+
+  heights = scene["foot_height_scan"].data.heights[0]
+  assert heights[0].item() < 0.1
+  assert heights[1].item() < 0.5
diff --git a/tests/test_fused_group.py b/tests/test_fused_group.py
new file mode 100644
index 0000000..45724e1
--- /dev/null
+++ b/tests/test_fused_group.py
@@ -0,0 +1,364 @@
+"""Tests for FusedActuatorGroup (fused stateless-control-law actuators)."""
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device, load_fixture_xml
+
+from mjlab.actuator import (
+  DcMotorActuator,
+  DcMotorActuatorCfg,
+  IdealPdActuator,
+  IdealPdActuatorCfg,
+  LearnedMlpActuator,
+)
+from mjlab.actuator.actuator import TransmissionType
+from mjlab.actuator.dc_actuator import dc_motor_clip
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+ROBOT_XML = load_fixture_xml("floating_base_articulated")
+TENDON_XML = load_fixture_xml("tendon_finger")
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+def make_entity(actuator_cfgs, num_envs, device):
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML),
+    articulation=EntityArticulationInfoCfg(actuators=actuator_cfgs),
+  )
+  entity = Entity(cfg)
+  model = entity.compile()
+  sim = Simulation(num_envs=num_envs, cfg=SimulationCfg(), model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+  return entity, sim
+
+
+def test_idealpd_actuators_fused(device):
+  """Ideal PD actuators with matching delay config fuse into one group."""
+  cfg1 = IdealPdActuatorCfg(target_names_expr=("joint1",), stiffness=50.0, damping=5.0)
+  cfg2 = IdealPdActuatorCfg(target_names_expr=("joint2",), stiffness=30.0, damping=3.0)
+  entity, _ = make_entity((cfg1, cfg2), num_envs=2, device=device)
+
+  assert len(entity._fused_actuator_group._groups) == 1
+  assert entity._fused_actuator_group._groups[0].target_ids.numel() == 2
+  assert len(entity._custom_actuators) == 0
+
+
+def test_different_delay_configs_separate_groups(device):
+  """Ideal PD actuators with different delay configs get separate groups."""
+  cfg1 = IdealPdActuatorCfg(
+    target_names_expr=("joint1",), stiffness=50.0, damping=5.0, delay_max_lag=3
+  )
+  cfg2 = IdealPdActuatorCfg(
+    target_names_expr=("joint2",), stiffness=50.0, damping=5.0, delay_max_lag=5
+  )
+  entity, _ = make_entity((cfg1, cfg2), num_envs=2, device=device)
+
+  assert len(entity._fused_actuator_group._groups) == 2
+
+
+def test_fusable_detection_by_compute():
+  """Fusability is keeping the shared stateless-law compute, not a flag."""
+  from mjlab.actuator import BuiltinPositionActuator
+
+  # IdealPd defines the shared law-applying compute; DcMotor inherits it.
+  assert DcMotorActuator.compute is IdealPdActuator.compute
+  # Custom compute (learned network, built-in field passthrough) opts out, with
+  # no flag and immune to the DcMotor -> LearnedMlp inheritance trap.
+  assert LearnedMlpActuator.compute is not IdealPdActuator.compute
+  assert BuiltinPositionActuator.compute is not IdealPdActuator.compute
+
+
+def test_dcmotor_fuses_separately_and_matches(device):
+  """DcMotor fuses into its own group (distinct law) and matches per-actuator."""
+  ideal = IdealPdActuatorCfg(target_names_expr=("joint1",), stiffness=50.0, damping=5.0)
+  dc = DcMotorActuatorCfg(
+    target_names_expr=("joint2",),
+    stiffness=50.0,
+    damping=5.0,
+    effort_limit=20.0,
+    saturation_effort=40.0,
+    velocity_limit=30.0,
+  )
+  entity, _ = make_entity((ideal, dc), num_envs=4, device=device)
+  fused = entity._fused_actuator_group
+
+  # Different control laws (clamp vs torque-speed curve) -> separate groups,
+  # nothing left on the custom path.
+  assert len(fused._groups) == 2
+  assert len(entity._custom_actuators) == 0
+
+  data = entity.data
+  # Large targets so the DC torque-speed clip is actually active.
+  data.joint_pos_target[:] = 10.0 * torch.randn_like(data.joint_pos_target)
+  data.joint_vel_target[:] = torch.randn_like(data.joint_vel_target)
+
+  fused.apply_controls(data)
+  for group in fused._groups:
+    got = data.data.ctrl[:, data.indexing.ctrl_ids[group.ctrl_ids]]
+    ref = torch.cat(
+      [act.compute(act.get_command(data)) for act in group.absorbed_actuators], dim=1
+    )
+    assert torch.equal(got, ref)
+
+
+def test_fused_matches_per_actuator(device):
+  """Fused control output is identical to per-actuator compute (no delay)."""
+  cfg1 = IdealPdActuatorCfg(
+    target_names_expr=("joint1",), stiffness=50.0, damping=5.0, effort_limit=100.0
+  )
+  cfg2 = IdealPdActuatorCfg(
+    target_names_expr=("joint2",), stiffness=30.0, damping=3.0, effort_limit=80.0
+  )
+  entity, _ = make_entity((cfg1, cfg2), num_envs=4, device=device)
+  data = entity.data
+  group = entity._fused_actuator_group._groups[0]
+
+  data.joint_pos_target[:] = torch.randn_like(data.joint_pos_target)
+  data.joint_vel_target[:] = torch.randn_like(data.joint_vel_target)
+
+  entity._fused_actuator_group.apply_controls(data)
+  fused_ctrl = data.data.ctrl[:, data.indexing.ctrl_ids[group.ctrl_ids]].clone()
+
+  reference = torch.cat(
+    [act.compute(act.get_command(data)) for act in group.absorbed_actuators], dim=1
+  )
+  assert torch.equal(fused_ctrl, reference)
+
+
+def test_set_gains_writes_through_view(device):
+  """Per-actuator set_gains mutates the fused gain tensor and its output."""
+  cfg1 = IdealPdActuatorCfg(
+    target_names_expr=("joint1",), stiffness=50.0, damping=5.0, effort_limit=1e6
+  )
+  cfg2 = IdealPdActuatorCfg(
+    target_names_expr=("joint2",), stiffness=30.0, damping=3.0, effort_limit=1e6
+  )
+  entity, _ = make_entity((cfg1, cfg2), num_envs=4, device=device)
+  data = entity.data
+  group = entity._fused_actuator_group._groups[0]
+  act0 = group.absorbed_actuators[0]
+  assert isinstance(act0, IdealPdActuator)
+  n0 = act0.target_ids.numel()
+
+  env_ids = torch.arange(4, device=device)
+  new_kp = torch.full((4, n0), 123.0, device=device)
+  act0.set_gains(env_ids, kp=new_kp)
+
+  # The view aliases the fused tensor in place.
+  assert torch.equal(group.params["stiffness"][:, :n0], new_kp)
+
+  data.joint_pos_target[:] = torch.randn_like(data.joint_pos_target)
+  entity._fused_actuator_group.apply_controls(data)
+  fused_ctrl = data.data.ctrl[:, data.indexing.ctrl_ids[group.ctrl_ids]]
+  expected0 = act0.compute(act0.get_command(data))
+  assert torch.equal(fused_ctrl[:, :n0], expected0)
+
+
+def test_fused_delay_applies_lag(device):
+  """A fused group with constant lag returns the command from `lag` steps ago."""
+  lag = 3
+  cfg = IdealPdActuatorCfg(
+    target_names_expr=("joint.*",),
+    stiffness=0.0,  # isolate the feedforward effort term.
+    damping=0.0,
+    effort_limit=1e9,
+    delay_min_lag=lag,
+    delay_max_lag=lag,
+  )
+  entity, _ = make_entity((cfg,), num_envs=2, device=device)
+  data = entity.data
+  group = entity._fused_actuator_group._groups[0]
+  assert group.delay_buffer is not None
+
+  # First append happened during a prior apply; drive a ramp and read it back.
+  data.joint_effort_target[:] = 0.0
+  entity._fused_actuator_group.apply_controls(data)  # seed history with 0.
+  seen = []
+  for step in range(1, 6):
+    data.joint_effort_target[:] = float(step)
+    entity._fused_actuator_group.apply_controls(data)
+    seen.append(data.data.ctrl[:, data.indexing.ctrl_ids[group.ctrl_ids]][0, 0].item())
+
+  # ctrl reflects the effort target from `lag` steps earlier; history starts at
+  # the seeded 0 and the buffer fills before the ramp shows through.
+  assert seen == [0.0, 0.0, 0.0, 1.0, 2.0]
+
+
+def test_no_idealpd_actuators_empty_group(device):
+  """With no ideal PD actuators the fused group is empty and harmless."""
+  from mjlab.actuator import BuiltinPositionActuatorCfg
+
+  cfg = BuiltinPositionActuatorCfg(
+    target_names_expr=("joint.*",), stiffness=50.0, damping=5.0
+  )
+  entity, _ = make_entity((cfg,), num_envs=2, device=device)
+  assert len(entity._fused_actuator_group._groups) == 0
+  entity._fused_actuator_group.apply_controls(entity.data)  # no-op, must not raise.
+
+
+def make_tendon_entity(actuator_cfgs, num_envs, device):
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(TENDON_XML),
+    articulation=EntityArticulationInfoCfg(actuators=actuator_cfgs),
+  )
+  entity = Entity(cfg)
+  model = entity.compile()
+  sim = Simulation(num_envs=num_envs, cfg=SimulationCfg(), model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+  return entity, sim
+
+
+def test_tendon_transmission_fused_matches_per_actuator(device):
+  """TENDON-transmission ideal PD actuators fuse and gather the right fields."""
+  cfg = IdealPdActuatorCfg(
+    target_names_expr=("finger_tendon",),
+    transmission_type=TransmissionType.TENDON,
+    stiffness=50.0,
+    damping=5.0,
+    effort_limit=100.0,
+  )
+  entity, _ = make_tendon_entity((cfg,), num_envs=4, device=device)
+  data = entity.data
+  group = entity._fused_actuator_group._groups[0]
+  assert group.transmission_type == TransmissionType.TENDON
+
+  data.tendon_len_target[:] = torch.randn_like(data.tendon_len_target)
+  data.tendon_vel_target[:] = torch.randn_like(data.tendon_vel_target)
+  data.tendon_effort_target[:] = torch.randn_like(data.tendon_effort_target)
+
+  entity._fused_actuator_group.apply_controls(data)
+  fused_ctrl = data.data.ctrl[:, data.indexing.ctrl_ids[group.ctrl_ids]].clone()
+
+  act0 = group.absorbed_actuators[0]
+  reference = act0.compute(act0.get_command(data))
+  assert torch.equal(fused_ctrl, reference)
+
+
+def test_fused_group_shares_one_lag_per_env(device):
+  """Fused actuators sharing a delay config share one lag per env, not one each."""
+  cfg1 = IdealPdActuatorCfg(
+    target_names_expr=("joint1",),
+    stiffness=0.0,
+    damping=0.0,
+    effort_limit=1e9,
+    delay_min_lag=0,
+    delay_max_lag=5,
+  )
+  cfg2 = IdealPdActuatorCfg(
+    target_names_expr=("joint2",),
+    stiffness=0.0,
+    damping=0.0,
+    effort_limit=1e9,
+    delay_min_lag=0,
+    delay_max_lag=5,
+  )
+  entity, _ = make_entity((cfg1, cfg2), num_envs=8, device=device)
+  group = entity._fused_actuator_group._groups[0]
+  assert len(group.absorbed_actuators) == 2
+  act0, act1 = group.absorbed_actuators
+
+  # Both actuators alias the same shared DelayBuffer.
+  assert group.delay_buffer is not None
+  assert act0._delay_buffer is act1._delay_buffer is group.delay_buffer
+
+  # Setting lags through one actuator's handle moves the whole group's lags,
+  # since set_lags reaches into the shared buffer.
+  env_ids = torch.arange(8, device=device)
+  lags = torch.tensor([0, 1, 2, 3, 4, 5, 3, 2], device=device)
+  act0.set_lags(lags, env_ids)
+  assert torch.equal(group.delay_buffer.current_lags, lags)
+  zeros = torch.zeros(8, dtype=torch.long, device=device)
+  act1.set_lags(zeros, env_ids)
+  assert torch.equal(group.delay_buffer.current_lags, zeros)
+
+
+def test_fused_group_reset_clears_shared_buffer(device):
+  """Resetting one absorbed actuator's env_ids clears the shared delay buffer."""
+  cfg1 = IdealPdActuatorCfg(
+    target_names_expr=("joint1",),
+    stiffness=0.0,
+    damping=0.0,
+    effort_limit=1e9,
+    delay_min_lag=2,
+    delay_max_lag=2,
+  )
+  cfg2 = IdealPdActuatorCfg(
+    target_names_expr=("joint2",),
+    stiffness=0.0,
+    damping=0.0,
+    effort_limit=1e9,
+    delay_min_lag=2,
+    delay_max_lag=2,
+  )
+  entity, _ = make_entity((cfg1, cfg2), num_envs=4, device=device)
+  data = entity.data
+  group = entity._fused_actuator_group._groups[0]
+  assert group.delay_buffer is not None
+
+  data.joint_effort_target[:] = 7.0
+  for _ in range(3):
+    entity._fused_actuator_group.apply_controls(data)
+  assert torch.all(group.delay_buffer._buffer.current_length == 3)
+
+  # Resetting env 1 through one absorbed actuator zeros the shared buffer's
+  # history and counter for that env, visible to the other absorbed actuator.
+  reset_ids = torch.tensor([1], device=device)
+  group.absorbed_actuators[0].reset(reset_ids)
+  assert group.delay_buffer._buffer.current_length[1] == 0
+  assert group.delay_buffer._buffer.current_length[0] == 3
+
+
+def test_dcmotor_effort_limit_randomization_updates_torque_speed_curve(device):
+  """DC motor torque-speed clip tracks force_limit after it is randomized.
+
+  Regression: the corner velocity of the torque-speed curve used to be cached
+  once at initialize() time, so calling set_effort_limit (as domain
+  randomization does) silently left the clip using the stale, pre-randomized
+  force_limit.
+  """
+  cfg = DcMotorActuatorCfg(
+    target_names_expr=("joint1",),
+    stiffness=0.0,
+    damping=0.0,
+    effort_limit=20.0,
+    saturation_effort=40.0,
+    velocity_limit=30.0,
+  )
+  entity, _ = make_entity((cfg,), num_envs=2, device=device)
+  data = entity.data
+  group = entity._fused_actuator_group._groups[0]
+  act0 = group.absorbed_actuators[0]
+  assert isinstance(act0, DcMotorActuator)
+
+  env_ids = torch.arange(2, device=device)
+  new_limit = torch.full((2, 1), 5.0, device=device)
+  act0.set_effort_limit(env_ids, effort_limit=new_limit)
+
+  data.joint_effort_target[:] = 100.0
+  data.joint_vel_target[:] = 0.0
+  current_vel = act0.get_command(data).vel.clone()  # actual current joint vel.
+  entity._fused_actuator_group.apply_controls(data)
+  fused_ctrl = data.data.ctrl[:, data.indexing.ctrl_ids[group.ctrl_ids]]
+
+  assert act0.saturation_effort is not None
+  assert act0.velocity_limit_motor is not None
+  assert act0.force_limit is not None
+  expected = dc_motor_clip(
+    torch.full_like(fused_ctrl, 100.0),
+    act0.saturation_effort,
+    act0.velocity_limit_motor,
+    act0.force_limit,
+    current_vel,
+  )
+  assert torch.equal(fused_ctrl, expected)
+  # The randomized (not the original) force_limit bounds the clipped torque:
+  # with vel == 0 the corner velocity is never engaged, so the clamp is exactly
+  # +/- force_limit.
+  assert torch.all(current_vel == 0.0)
+  assert torch.allclose(fused_ctrl, new_limit)
diff --git a/tests/test_g1_constants.py b/tests/test_g1_constants.py
new file mode 100644
index 0000000..1c1edf5
--- /dev/null
+++ b/tests/test_g1_constants.py
@@ -0,0 +1,141 @@
+"""Tests for g1_constants.py."""
+
+import re
+
+import mujoco
+import numpy as np
+import pytest
+
+from mjlab.asset_zoo.robots.unitree_g1 import g1_constants
+from mjlab.entity import Entity
+from mjlab.utils.string import resolve_expr
+
+
+@pytest.fixture(scope="module")
+def g1_entity() -> Entity:
+  return Entity(g1_constants.get_g1_robot_cfg())
+
+
+@pytest.fixture(scope="module")
+def g1_model(g1_entity: Entity) -> mujoco.MjModel:
+  return g1_entity.spec.compile()
+
+
+# fmt: off
+@pytest.mark.parametrize(
+  "actuator_config,stiffness,damping",
+  [
+    (g1_constants.G1_ACTUATOR_5020, g1_constants.STIFFNESS_5020, g1_constants.DAMPING_5020),
+    (g1_constants.G1_ACTUATOR_7520_14, g1_constants.STIFFNESS_7520_14, g1_constants.DAMPING_7520_14),
+    (g1_constants.G1_ACTUATOR_7520_22, g1_constants.STIFFNESS_7520_22, g1_constants.DAMPING_7520_22),
+    (g1_constants.G1_ACTUATOR_4010, g1_constants.STIFFNESS_4010, g1_constants.DAMPING_4010),
+    (g1_constants.G1_ACTUATOR_WAIST, g1_constants.STIFFNESS_5020 * 2, g1_constants.DAMPING_5020 * 2),
+    (g1_constants.G1_ACTUATOR_ANKLE, g1_constants.STIFFNESS_5020 * 2, g1_constants.DAMPING_5020 * 2),
+  ],
+)
+# fmt: on
+def test_actuator_parameters(g1_model, actuator_config, stiffness, damping):
+  for i in range(g1_model.nu):
+    actuator = g1_model.actuator(i)
+    actuator_name = actuator.name
+    matches = any(
+      re.match(pattern, actuator_name) for pattern in actuator_config.target_names_expr
+    )
+    if matches:
+      assert actuator.gainprm[0] == stiffness
+      assert actuator.biasprm[1] == -stiffness
+      assert actuator.biasprm[2] == -damping
+      assert actuator.forcerange[0] == -actuator_config.effort_limit
+      assert actuator.forcerange[1] == actuator_config.effort_limit
+
+
+def test_keyframe_base_position(g1_model) -> None:
+  data = mujoco.MjData(g1_model)
+  mujoco.mj_resetDataKeyframe(g1_model, data, 0)
+  mujoco.mj_forward(g1_model, data)
+  np.testing.assert_array_equal(data.qpos[:3], g1_constants.KNEES_BENT_KEYFRAME.pos)
+  np.testing.assert_array_equal(data.qpos[3:7], g1_constants.KNEES_BENT_KEYFRAME.rot)
+
+
+def test_keyframe_joint_positions(g1_entity, g1_model) -> None:
+  """Test that keyframe joint positions match the configuration."""
+  key = g1_model.key("init_state")
+  expected_joint_pos = g1_constants.KNEES_BENT_KEYFRAME.joint_pos
+  assert expected_joint_pos is not None
+  expected_values = resolve_expr(expected_joint_pos, g1_entity.joint_names, 0.0)
+  for joint_name, expected_value in zip(
+    g1_entity.joint_names, expected_values, strict=True
+  ):
+    joint = g1_model.joint(joint_name)
+    qpos_idx = joint.qposadr[0]
+    actual_value = key.qpos[qpos_idx]
+    np.testing.assert_allclose(
+      actual_value,
+      expected_value,
+      rtol=1e-5,
+      err_msg=f"Joint {joint_name} position mismatch: "
+      f"expected {expected_value}, got {actual_value}",
+    )
+
+
+def test_foot_collision_geoms(g1_model) -> None:
+  foot_pattern = r"^(left|right)_foot[1-7]_collision$"
+  for i in range(g1_model.ngeom):
+    geom = g1_model.geom(i)
+    geom_name = geom.name
+    # Foot collision geoms should have condim=3, priority=1, and friction=0.6.
+    if re.match(foot_pattern, geom_name):
+      assert geom.condim == 3
+      assert geom.priority == 1
+      assert geom.friction[0] == 0.6
+
+
+def test_non_foot_collision_geoms(g1_model) -> None:
+  foot_pattern = r"^(left|right)_foot[1-7]_collision$"
+  for i in range(g1_model.ngeom):
+    geom = g1_model.geom(i)
+    geom_name = geom.name
+    if "_collision" not in geom_name:
+      continue
+    # Non-foot collision geoms should have condim=1
+    if not re.match(foot_pattern, geom_name):
+      assert geom.condim == 1
+
+
+def test_collision_geom_count(g1_model) -> None:
+  # There should be 7 geoms (capsules) per foot.
+  collision_geoms = [
+    g1_model.geom(i).name
+    for i in range(g1_model.ngeom)
+    if "_collision" in g1_model.geom(i).name
+  ]
+  assert len(collision_geoms) > 0
+  foot_geoms = [
+    name
+    for name in collision_geoms
+    if re.match(r"^(left|right)_foot[1-7]_collision$", name)
+  ]
+  assert len(foot_geoms) == 14
+
+
+def test_g1_entity_creation(g1_entity) -> None:
+  assert g1_entity.num_actuators == 29
+  assert g1_entity.num_joints == 29
+  assert g1_entity.is_actuated
+  assert not g1_entity.is_fixed_base
+
+
+def test_g1_actuators_configured_correctly(g1_model):
+  """Verify that all G1 actuators have correct control and force limiting.
+
+  All 29 G1 actuators should have ctrllimited=False (allowing setpoints beyond
+  joint limits) and forcelimited=True (limiting forces to effort limits).
+  """
+  for i in range(g1_model.nu):
+    actuator_name = g1_model.actuator(i).name
+    assert g1_model.actuator_ctrllimited[i] == 0, (
+      f"Actuator '{actuator_name}' has ctrllimited=True, expected False"
+    )
+    assert g1_model.actuator_forcelimited[i] == 1, (
+      f"Actuator '{actuator_name}' has forcelimited=False, expected True"
+    )
diff --git a/tests/test_go1_constants.py b/tests/test_go1_constants.py
new file mode 100644
index 0000000..c782408
--- /dev/null
+++ b/tests/test_go1_constants.py
@@ -0,0 +1,114 @@
+"""Tests for go1_constants.py."""
+
+import re
+
+import mujoco
+import numpy as np
+import pytest
+
+from mjlab.asset_zoo.robots.unitree_go1 import go1_constants
+from mjlab.entity import Entity
+from mjlab.utils.string import resolve_expr
+
+
+@pytest.fixture(scope="module")
+def go1_entity() -> Entity:
+  return Entity(go1_constants.get_go1_robot_cfg())
+
+
+@pytest.fixture(scope="module")
+def go1_model(go1_entity: Entity) -> mujoco.MjModel:
+  return go1_entity.spec.compile()
+
+
+# fmt: off
+@pytest.mark.parametrize(
+  "actuator_config,stiffness,damping",
+  [
+    (go1_constants.GO1_HIP_ACTUATOR_CFG, go1_constants.STIFFNESS_HIP, go1_constants.DAMPING_HIP),
+    (go1_constants.GO1_KNEE_ACTUATOR_CFG, go1_constants.STIFFNESS_KNEE, go1_constants.DAMPING_KNEE),
+  ],
+)
+# fmt: on
+def test_actuator_parameters(go1_model, actuator_config, stiffness, damping):
+  for i in range(go1_model.nu):
+    actuator = go1_model.actuator(i)
+    actuator_name = actuator.name
+    matches = any(
+      re.match(pattern, actuator_name) for pattern in actuator_config.target_names_expr
+    )
+    if matches:
+      assert actuator.gainprm[0] == stiffness
+      assert actuator.biasprm[1] == -stiffness
+      assert actuator.biasprm[2] == -damping
+      assert actuator.forcerange[0] == -actuator_config.effort_limit
+      assert actuator.forcerange[1] == actuator_config.effort_limit
+
+
+def test_keyframe_joint_positions(go1_entity, go1_model) -> None:
+  """Test that keyframe joint positions match the configuration."""
+  key = go1_model.key("init_state")
+  expected_joint_pos = go1_constants.INIT_STATE.joint_pos
+  assert expected_joint_pos is not None
+  expected_values = resolve_expr(expected_joint_pos, go1_entity.joint_names, 0.0)
+  for joint_name, expected_value in zip(
+    go1_entity.joint_names, expected_values, strict=True
+  ):
+    joint = go1_model.joint(joint_name)
+    qpos_idx = joint.qposadr[0]
+    actual_value = key.qpos[qpos_idx]
+    np.testing.assert_allclose(
+      actual_value,
+      expected_value,
+      rtol=1e-5,
+      err_msg=f"Joint {joint_name} position mismatch: "
+      f"expected {expected_value}, got {actual_value}",
+    )
+
+
+def test_foot_collision_geoms(go1_model) -> None:
+  """Foot collision geoms should have specific properties."""
+  foot_pattern = r"^[FR][LR]_foot_collision$"
+  for i in range(go1_model.ngeom):
+    geom = go1_model.geom(i)
+    if re.match(foot_pattern, geom.name):
+      assert geom.condim == 6
+      assert geom.priority == 1
+      assert geom.friction[0] == 1.0
+
+
+def test_all_collision_geoms_enabled(go1_model) -> None:
+  """Every *_collision geom, including numbered ones, must stay collidable.
+
+  The go1 XML numbers its secondary collision capsules (FR_thigh_collision1,
+  ...), which a pattern anchored at "_collision" would silently drop, letting
+  disable_other_geoms zero their contype. Guard against that regression with
+  an oracle independent of the config's own regex resolution.
+  """
+  collision_geoms = [
+    go1_model.geom(i)
+    for i in range(go1_model.ngeom)
+    if "_collision" in go1_model.geom(i).name
+  ]
+  assert len(collision_geoms) == 30
+  for geom in collision_geoms:
+    assert geom.contype == 1, f"{geom.name} lost its contype"
+    assert geom.conaffinity == 1, f"{geom.name} lost its conaffinity"
+
+
+def test_collision_geom_count(go1_model) -> None:
+  """Go1 should have 4 foot collision geoms."""
+  foot_pattern = r"^[FR][LR]_foot_collision$"
+  foot_geoms = [
+    g.name for g in [go1_model.geom(i) for i in range(go1_model.ngeom)]
+    if re.match(foot_pattern, g.name)
+  ]
+  assert len(foot_geoms) == 4
+
+
+def test_go1_entity_creation(go1_entity) -> None:
+  """Test basic Go1 entity properties."""
+  assert go1_entity.num_actuators == 12
+  assert go1_entity.num_joints == 12
+  assert go1_entity.is_actuated
+  assert not go1_entity.is_fixed_base
diff --git a/tests/test_gpu_selection.py b/tests/test_gpu_selection.py
new file mode 100644
index 0000000..f02cadb
--- /dev/null
+++ b/tests/test_gpu_selection.py
@@ -0,0 +1,128 @@
+"""Tests for GPU selection utilities."""
+
+import os
+
+import pytest
+
+from mjlab.utils.gpu import select_gpus
+
+
+@pytest.fixture(autouse=True)
+def clean_cuda_env():
+  """Clean CUDA_VISIBLE_DEVICES before each test."""
+  original = os.environ.get("CUDA_VISIBLE_DEVICES")
+  yield
+  # Restore original value after test.
+  if original is None:
+    os.environ.pop("CUDA_VISIBLE_DEVICES", None)
+  else:
+    os.environ["CUDA_VISIBLE_DEVICES"] = original
+
+
+def test_select_gpus_with_visible_devices_set():
+  """Respects CUDA_VISIBLE_DEVICES when selecting GPUs."""
+  os.environ["CUDA_VISIBLE_DEVICES"] = "0,1,2,3"
+
+  # Select first two GPUs (indices 0, 1 -> physical GPUs 0, 1).
+  selected, num = select_gpus([0, 1])
+  assert selected == [0, 1]
+  assert num == 2
+
+
+def test_select_gpus_with_non_contiguous_devices():
+  """Handles non-contiguous CUDA_VISIBLE_DEVICES correctly."""
+  os.environ["CUDA_VISIBLE_DEVICES"] = "1,3,5"
+
+  # Index 0 -> physical GPU 1.
+  selected, num = select_gpus([0])
+  assert selected == [1]
+  assert num == 1
+
+  # Index 1 -> physical GPU 3.
+  selected, num = select_gpus([1])
+  assert selected == [3]
+  assert num == 1
+
+  # Indices 0, 2 -> physical GPUs 1, 5.
+  selected, num = select_gpus([0, 2])
+  assert selected == [1, 5]
+  assert num == 2
+
+
+def test_select_gpus_all_option():
+  """Selects all GPUs when 'all' is specified."""
+  os.environ["CUDA_VISIBLE_DEVICES"] = "2,4,6"
+
+  selected, num = select_gpus("all")
+  assert selected == [2, 4, 6]
+  assert num == 3
+
+
+def test_select_gpus_single_gpu():
+  """Correctly selects a single GPU."""
+  os.environ["CUDA_VISIBLE_DEVICES"] = "0,1"
+
+  selected, num = select_gpus([0])
+  assert selected == [0]
+  assert num == 1
+
+
+def test_select_gpus_with_spaces():
+  """Handles CUDA_VISIBLE_DEVICES with spaces correctly."""
+  os.environ["CUDA_VISIBLE_DEVICES"] = " 0 , 1 , 2 "
+
+  selected, num = select_gpus([1, 2])
+  assert selected == [1, 2]
+  assert num == 2
+
+
+def test_select_gpus_empty_segments():
+  """Handles empty segments in CUDA_VISIBLE_DEVICES."""
+  # This can happen with malformed environment variables.
+  os.environ["CUDA_VISIBLE_DEVICES"] = "0,,2"
+
+  selected, num = select_gpus([0, 1])
+  assert selected == [0, 2]
+  assert num == 2
+
+
+def test_select_gpus_respects_user_order():
+  """Preserves the order specified by the user."""
+  os.environ["CUDA_VISIBLE_DEVICES"] = "0,1,2,3"
+
+  # User requests in reverse order.
+  selected, num = select_gpus([3, 2, 1, 0])
+  assert selected == [3, 2, 1, 0]
+  assert num == 4
+
+
+def test_select_gpus_cpu_mode_explicit():
+  """Selects CPU mode when None is specified."""
+  os.environ["CUDA_VISIBLE_DEVICES"] = "0,1"
+
+  selected, num = select_gpus(None)
+  assert selected is None
+  assert num == 0
+
+
+def test_select_gpus_cpu_mode_empty_cuda_visible_devices():
+  """Selects CPU mode when CUDA_VISIBLE_DEVICES is empty."""
+  os.environ["CUDA_VISIBLE_DEVICES"] = ""
+
+  # Should return CPU mode (None, 0) since no GPUs are visible.
+  selected, num = select_gpus([0])
+  assert selected is None
+  assert num == 0
+
+
+def test_select_gpus_mig_uuids():
+  """Handles MIG GPU UUIDs in CUDA_VISIBLE_DEVICES."""
+  os.environ["CUDA_VISIBLE_DEVICES"] = "MIG-GPU-abc-123,MIG-GPU-def-456"
+
+  selected, num = select_gpus("all")
+  assert selected == ["MIG-GPU-abc-123", "MIG-GPU-def-456"]
+  assert num == 2
+
+  selected, num = select_gpus([0])
+  assert selected == ["MIG-GPU-abc-123"]
+  assert num == 1
diff --git a/tests/test_lab_api_math.py b/tests/test_lab_api_math.py
new file mode 100644
index 0000000..8400287
--- /dev/null
+++ b/tests/test_lab_api_math.py
@@ -0,0 +1,26 @@
+"""Tests for mjlab.utils.lab_api.math module."""
+
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.utils.lab_api.math import apply_delta_pose
+
+
+@pytest.fixture
+def device():
+  return get_test_device()
+
+
+def test_apply_delta_pose_zero_rotation_is_finite_and_identity(device):
+  """Zero rotation delta should return finite values and preserve input pose."""
+  source_pos = torch.zeros(2, 3, device=device)
+  source_rot = torch.tensor([[1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], device=device)
+  delta_pose = torch.zeros(2, 6, device=device)
+
+  target_pos, target_rot = apply_delta_pose(source_pos, source_rot, delta_pose)
+
+  assert torch.isfinite(target_pos).all()
+  assert torch.isfinite(target_rot).all()
+  assert torch.allclose(target_pos, source_pos)
+  assert torch.allclose(target_rot, source_rot)
diff --git a/tests/test_learned_actuator.py b/tests/test_learned_actuator.py
new file mode 100644
index 0000000..9552d43
--- /dev/null
+++ b/tests/test_learned_actuator.py
@@ -0,0 +1,466 @@
+"""Tests for learned MLP actuator."""
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.actuator import LearnedMlpActuator, LearnedMlpActuatorCfg
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+ROBOT_XML = """
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="1.0"/>
+      <body name="link1" pos="0 0 0">
+        <joint name="joint1" type="hinge" axis="0 0 1" range="-3.14 3.14"/>
+        <geom name="link1_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+ROBOT_XML_TWO_JOINTS = """
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="1.0"/>
+      <body name="link1" pos="0 0 0">
+        <joint name="joint1" type="hinge" axis="0 0 1" range="-3.14 3.14"/>
+        <geom name="link1_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+        <body name="link2" pos="0.2 0 0">
+          <joint name="joint2" type="hinge" axis="0 0 1" range="-3.14 3.14"/>
+          <geom name="link2_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+        </body>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+@pytest.fixture(scope="module")
+def identity_network_file(tmp_path_factory):
+  """Create a simple identity network: output = sum of all inputs."""
+
+  class IdentityNet(torch.nn.Module):
+    def forward(self, x):
+      # Sum all inputs and return as single output per joint.
+      return x.sum(dim=1, keepdim=True)
+
+  net = IdentityNet()
+  tmp_dir = tmp_path_factory.mktemp("networks")
+  network_path = tmp_dir / "identity_net.pt"
+  torch.jit.script(net).save(str(network_path))
+  return str(network_path)
+
+
+@pytest.fixture(scope="module")
+def constant_network_file(tmp_path_factory):
+  """Create a network that returns constant value regardless of input."""
+
+  class ConstantNet(torch.nn.Module):
+    def forward(self, x):
+      # Return constant 10.0 for each joint.
+      return torch.full((x.shape[0], 1), 10.0, device=x.device)
+
+  net = ConstantNet()
+  tmp_dir = tmp_path_factory.mktemp("networks")
+  network_path = tmp_dir / "constant_net.pt"
+  torch.jit.script(net).save(str(network_path))
+  return str(network_path)
+
+
+@pytest.fixture(scope="module")
+def subtract_network_file(tmp_path_factory):
+  """Create a network that subtracts second half from first half of inputs.
+
+  For input [a, b, c, d], returns (a + b) - (c + d).
+  This is sensitive to input order, unlike sum-based networks.
+  """
+
+  class SubtractNet(torch.nn.Module):
+    def forward(self, x):
+      # Split input in half and subtract second half from first half.
+      mid = x.shape[1] // 2
+      first_half = x[:, :mid].sum(dim=1, keepdim=True)
+      second_half = x[:, mid:].sum(dim=1, keepdim=True)
+      return first_half - second_half
+
+  net = SubtractNet()
+  tmp_dir = tmp_path_factory.mktemp("networks")
+  network_path = tmp_dir / "subtract_net.pt"
+  torch.jit.script(net).save(str(network_path))
+  return str(network_path)
+
+
+def create_entity_with_actuator(actuator_cfg):
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML),
+    articulation=EntityArticulationInfoCfg(actuators=(actuator_cfg,)),
+  )
+  return Entity(cfg)
+
+
+def initialize_entity(entity, device, num_envs=1):
+  model = entity.compile()
+  sim_cfg = SimulationCfg()
+  sim = Simulation(num_envs=num_envs, cfg=sim_cfg, model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+  return entity, sim
+
+
+def test_learned_mlp_network_loads(device, identity_network_file):
+  """Verify network loads from TorchScript file and initializes."""
+  entity = create_entity_with_actuator(
+    LearnedMlpActuatorCfg(
+      target_names_expr=("joint.*",),
+      network_file=identity_network_file,
+      pos_scale=1.0,
+      vel_scale=1.0,
+      torque_scale=1.0,
+      input_order="pos_vel",
+      history_length=1,
+      saturation_effort=100.0,
+      velocity_limit=30.0,
+      effort_limit=50.0,
+    )
+  )
+
+  entity, sim = initialize_entity(entity, device)
+
+  # Verify network was loaded.
+  actuator = entity.actuators[0]
+  assert isinstance(actuator, LearnedMlpActuator)
+  assert actuator.network is not None
+  assert actuator._pos_error_history is not None
+  assert actuator._vel_history is not None
+
+
+def test_learned_mlp_history_indexing(device, identity_network_file):
+  """Test that history_length uses consecutive timesteps."""
+  entity = create_entity_with_actuator(
+    LearnedMlpActuatorCfg(
+      target_names_expr=("joint.*",),
+      network_file=identity_network_file,
+      pos_scale=1.0,
+      vel_scale=0.0,  # Zero out velocity contribution.
+      torque_scale=1.0,
+      input_order="pos_vel",
+      history_length=3,  # Use current + 2 previous timesteps.
+      saturation_effort=100.0,
+      velocity_limit=30.0,
+      effort_limit=100.0,
+    )
+  )
+
+  entity, sim = initialize_entity(entity, device)
+
+  # Set up state at rest.
+  joint_pos = torch.tensor([[0.0]], device=device)
+  joint_vel = torch.tensor([[0.0]], device=device)
+  entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  # Set position targets to create known position errors.
+  # Step 0: pos_error = 1.0
+  # Step 1: pos_error = 2.0
+  # Step 2: pos_error = 3.0
+  targets = [
+    torch.tensor([[1.0]], device=device),
+    torch.tensor([[2.0]], device=device),
+    torch.tensor([[3.0]], device=device),
+  ]
+
+  for target in targets:
+    entity.set_joint_position_target(target)
+    entity.set_joint_velocity_target(joint_vel)
+    entity.set_joint_effort_target(torch.zeros(1, 1, device=device))
+    entity.write_data_to_sim()
+
+  # After 3 steps with history_length=3:
+  # Network input: [current, -1 step, -2 steps] = [3.0, 2.0, 1.0]
+  # Identity network sums: 3.0 + 2.0 + 1.0 = 6.0
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([6.0], device=device), atol=1e-4)
+
+
+def test_learned_mlp_input_order_pos_vel(device, subtract_network_file):
+  """Verify input_order='pos_vel' concatenates position then velocity."""
+  entity = create_entity_with_actuator(
+    LearnedMlpActuatorCfg(
+      target_names_expr=("joint.*",),
+      network_file=subtract_network_file,
+      pos_scale=1.0,
+      vel_scale=1.0,
+      torque_scale=1.0,
+      input_order="pos_vel",
+      history_length=1,
+      saturation_effort=100.0,
+      velocity_limit=30.0,
+      effort_limit=100.0,
+    )
+  )
+
+  entity, sim = initialize_entity(entity, device)
+
+  # Set state: pos_error = 2.0, vel = 3.0.
+  joint_pos = torch.tensor([[0.0]], device=device)
+  joint_vel = torch.tensor([[3.0]], device=device)
+  entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  entity.set_joint_position_target(torch.tensor([[2.0]], device=device))
+  entity.set_joint_velocity_target(torch.zeros(1, 1, device=device))
+  entity.set_joint_effort_target(torch.zeros(1, 1, device=device))
+  entity.write_data_to_sim()
+
+  # Network input: [pos_error, vel] = [2.0, 3.0]
+  # Subtract network: 2.0 - 3.0 = -1.0
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([-1.0], device=device), atol=1e-4)
+
+
+def test_learned_mlp_input_order_vel_pos(device, subtract_network_file):
+  """Verify input_order='vel_pos' concatenates velocity then position."""
+  entity = create_entity_with_actuator(
+    LearnedMlpActuatorCfg(
+      target_names_expr=("joint.*",),
+      network_file=subtract_network_file,
+      pos_scale=1.0,
+      vel_scale=1.0,
+      torque_scale=1.0,
+      input_order="vel_pos",
+      history_length=1,
+      saturation_effort=100.0,
+      velocity_limit=30.0,
+      effort_limit=100.0,
+    )
+  )
+
+  entity, sim = initialize_entity(entity, device)
+
+  # Set state: pos_error = 2.0, vel = 3.0.
+  joint_pos = torch.tensor([[0.0]], device=device)
+  joint_vel = torch.tensor([[3.0]], device=device)
+  entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  entity.set_joint_position_target(torch.tensor([[2.0]], device=device))
+  entity.set_joint_velocity_target(torch.zeros(1, 1, device=device))
+  entity.set_joint_effort_target(torch.zeros(1, 1, device=device))
+  entity.write_data_to_sim()
+
+  # Network input: [vel, pos_error] = [3.0, 2.0]
+  # Subtract network: 3.0 - 2.0 = 1.0 (opposite of pos_vel!)
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([1.0], device=device), atol=1e-4)
+
+
+def test_learned_mlp_scaling_applied(device, identity_network_file):
+  """Test pos_scale, vel_scale, torque_scale are applied correctly."""
+  entity = create_entity_with_actuator(
+    LearnedMlpActuatorCfg(
+      target_names_expr=("joint.*",),
+      network_file=identity_network_file,
+      pos_scale=2.0,
+      vel_scale=3.0,
+      torque_scale=4.0,
+      input_order="pos_vel",
+      history_length=1,
+      saturation_effort=100.0,
+      velocity_limit=30.0,
+      effort_limit=100.0,
+    )
+  )
+
+  entity, sim = initialize_entity(entity, device)
+
+  # Set state: pos_error = 1.0, vel = 1.0.
+  joint_pos = torch.tensor([[0.0]], device=device)
+  joint_vel = torch.tensor([[1.0]], device=device)
+  entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  entity.set_joint_position_target(torch.tensor([[1.0]], device=device))
+  entity.set_joint_velocity_target(torch.zeros(1, 1, device=device))
+  entity.set_joint_effort_target(torch.zeros(1, 1, device=device))
+  entity.write_data_to_sim()
+
+  # Network input: [1.0 * 2.0, 1.0 * 3.0] = [2.0, 3.0]
+  # Identity network sums: 2.0 + 3.0 = 5.0
+  # Output scaled: 5.0 * 4.0 = 20.0
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([20.0], device=device), atol=1e-4)
+
+
+def test_learned_mlp_reset_clears_history(device, identity_network_file):
+  """Test reset zeroes history buffers for specified environments."""
+  entity = create_entity_with_actuator(
+    LearnedMlpActuatorCfg(
+      target_names_expr=("joint.*",),
+      network_file=identity_network_file,
+      pos_scale=1.0,
+      vel_scale=1.0,
+      torque_scale=1.0,
+      input_order="pos_vel",
+      history_length=2,
+      saturation_effort=100.0,
+      velocity_limit=30.0,
+      effort_limit=100.0,
+    )
+  )
+
+  entity, sim = initialize_entity(entity, device, num_envs=2)
+
+  # Set state and targets to fill buffers.
+  joint_pos = torch.tensor([[0.0], [0.0]], device=device)
+  joint_vel = torch.tensor([[1.0], [1.0]], device=device)
+  entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  entity.set_joint_position_target(torch.tensor([[5.0], [5.0]], device=device))
+  entity.set_joint_velocity_target(torch.zeros(2, 1, device=device))
+  entity.set_joint_effort_target(torch.zeros(2, 1, device=device))
+  entity.write_data_to_sim()
+
+  # Reset only env 0.
+  entity.reset(torch.tensor([0], device=device))
+
+  # Check history buffers.
+  actuator = entity.actuators[0]
+  assert isinstance(actuator, LearnedMlpActuator)
+  assert actuator._pos_error_history is not None
+  assert actuator._vel_history is not None
+  assert actuator._pos_error_history.current_length[0] == 0
+  assert actuator._pos_error_history.current_length[1] > 0
+  assert actuator._vel_history.current_length[0] == 0
+  assert actuator._vel_history.current_length[1] > 0
+
+
+def test_learned_mlp_inherits_dc_motor_limits(device, constant_network_file):
+  """Test that DC motor saturation_effort and velocity limits apply."""
+  saturation_effort = 20.0
+  velocity_limit = 30.0
+
+  entity = create_entity_with_actuator(
+    LearnedMlpActuatorCfg(
+      target_names_expr=("joint.*",),
+      network_file=constant_network_file,  # Always outputs 10.0.
+      pos_scale=1.0,
+      vel_scale=1.0,
+      torque_scale=100.0,  # Scale to 1000.0 to exceed limits.
+      input_order="pos_vel",
+      history_length=1,
+      saturation_effort=saturation_effort,
+      velocity_limit=velocity_limit,
+      effort_limit=saturation_effort,  # Set to saturation to not constrain.
+    )
+  )
+
+  entity, sim = initialize_entity(entity, device)
+
+  # At zero velocity, should be clipped to saturation_effort.
+  joint_pos = torch.tensor([[0.0]], device=device)
+  joint_vel = torch.tensor([[0.0]], device=device)
+  entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  entity.set_joint_position_target(torch.tensor([[1.0]], device=device))
+  entity.set_joint_velocity_target(torch.zeros(1, 1, device=device))
+  entity.set_joint_effort_target(torch.zeros(1, 1, device=device))
+  entity.write_data_to_sim()
+
+  # Network outputs 10.0, scaled by 100.0 = 1000.0.
+  # Should be clipped to saturation_effort = 20.0.
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([saturation_effort], device=device))
+
+
+def test_learned_mlp_dc_motor_zero_torque_at_max_velocity(
+  device, constant_network_file
+):
+  """Test that DC motor produces zero torque at max velocity."""
+  saturation_effort = 20.0
+  velocity_limit = 30.0
+
+  entity = create_entity_with_actuator(
+    LearnedMlpActuatorCfg(
+      target_names_expr=("joint.*",),
+      network_file=constant_network_file,  # Always outputs 10.0.
+      pos_scale=1.0,
+      vel_scale=1.0,
+      torque_scale=100.0,  # Scale to 1000.0.
+      input_order="pos_vel",
+      history_length=1,
+      saturation_effort=saturation_effort,
+      velocity_limit=velocity_limit,
+      effort_limit=saturation_effort,  # Set to saturation to not constrain.
+    )
+  )
+
+  entity, sim = initialize_entity(entity, device)
+
+  # At max velocity, should produce zero torque.
+  joint_pos = torch.tensor([[0.0]], device=device)
+  joint_vel = torch.tensor([[velocity_limit]], device=device)
+  entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  entity.set_joint_position_target(torch.tensor([[1.0]], device=device))
+  entity.set_joint_velocity_target(torch.zeros(1, 1, device=device))
+  entity.set_joint_effort_target(torch.zeros(1, 1, device=device))
+  entity.write_data_to_sim()
+
+  # At max velocity, DC motor should clip to zero.
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([0.0], device=device), atol=1e-5)
+
+
+def test_learned_mlp_multi_joint_reshaping(device, identity_network_file):
+  """Test that multi-joint reshaping works correctly."""
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML_TWO_JOINTS),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        LearnedMlpActuatorCfg(
+          target_names_expr=("joint.*",),
+          network_file=identity_network_file,
+          pos_scale=1.0,
+          vel_scale=1.0,
+          torque_scale=1.0,
+          input_order="pos_vel",
+          history_length=1,
+          saturation_effort=100.0,
+          velocity_limit=30.0,
+          effort_limit=100.0,
+        ),
+      )
+    ),
+  )
+
+  entity = Entity(cfg)
+  model = entity.compile()
+  sim_cfg = SimulationCfg()
+  sim = Simulation(num_envs=1, cfg=sim_cfg, model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+
+  # Set different states for each joint.
+  # Joint 1: pos_error = 1.0, vel = 2.0
+  # Joint 2: pos_error = 3.0, vel = 4.0
+  joint_pos = torch.tensor([[0.0, 0.0]], device=device)
+  joint_vel = torch.tensor([[2.0, 4.0]], device=device)
+  entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  entity.set_joint_position_target(torch.tensor([[1.0, 3.0]], device=device))
+  entity.set_joint_velocity_target(torch.zeros(1, 2, device=device))
+  entity.set_joint_effort_target(torch.zeros(1, 2, device=device))
+  entity.write_data_to_sim()
+
+  # Network input for joint 1: [1.0, 2.0] → sum = 3.0
+  # Network input for joint 2: [3.0, 4.0] → sum = 7.0
+  ctrl = sim.data.ctrl[0]
+  assert torch.allclose(ctrl, torch.tensor([3.0, 7.0], device=device), atol=1e-4)
diff --git a/tests/test_manager_config_immutability.py b/tests/test_manager_config_immutability.py
new file mode 100644
index 0000000..963e5bd
--- /dev/null
+++ b/tests/test_manager_config_immutability.py
@@ -0,0 +1,172 @@
+"""Tests for manager config immutability.
+
+Managers should not mutate the original config objects passed to them.
+This allows the same config to be reused across multiple manager instantiations.
+"""
+
+import inspect
+from unittest.mock import Mock
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.entity import Entity, EntityCfg
+from mjlab.managers.observation_manager import (
+  ObservationGroupCfg,
+  ObservationManager,
+  ObservationTermCfg,
+)
+from mjlab.managers.reward_manager import RewardManager, RewardTermCfg
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+
+@pytest.fixture
+def device():
+  return get_test_device()
+
+
+@pytest.fixture
+def mock_env(device):
+  env = Mock()
+  env.num_envs = 2
+  env.device = device
+  env.step_dt = 0.02
+  env.max_episode_length_s = 10.0
+  env.scene = {}
+  return env
+
+
+class ClassObsTerm:
+  """Class-based observation term that triggers func mutation."""
+
+  def __init__(self, cfg, env):
+    self.device = env.device
+
+  def __call__(self, env):
+    return torch.zeros((env.num_envs, 3), device=self.device)
+
+
+class ClassRewardTerm:
+  """Class-based reward term that triggers func mutation."""
+
+  def __init__(self, cfg, env):
+    self.device = env.device
+
+  def __call__(self, env):
+    return torch.ones(env.num_envs, device=self.device)
+
+
+def test_manager_preserves_class_func(mock_env):
+  """Managers should not mutate class-based func to instance.
+
+  When term_cfg.func is a class, _resolve_common_term_cfg instantiates it.
+  Without copying term_cfg first, this mutates the original config.
+  """
+  term_cfg = ObservationTermCfg(func=ClassObsTerm, params={})
+
+  assert inspect.isclass(term_cfg.func), "precondition: func should be a class"
+
+  cfg = {"actor": ObservationGroupCfg(terms={"obs1": term_cfg})}
+  _ = ObservationManager(cfg, mock_env)
+
+  assert inspect.isclass(term_cfg.func), "func was mutated from class to instance"
+
+
+def test_observation_shared_terms_between_groups(mock_env):
+  """Terms shared between policy and critic groups get independent settings."""
+  term_cfg = ObservationTermCfg(func=ClassObsTerm, params={})
+
+  cfg = {
+    "actor": ObservationGroupCfg(terms={"obs": term_cfg}, history_length=5),
+    "critic": ObservationGroupCfg(terms={"obs": term_cfg}),  # no history
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  policy_obs = manager.compute()["actor"]
+  critic_obs = manager.compute()["critic"]
+
+  # Policy has history (5 * 3 = 15), critic doesn't (3).
+  assert isinstance(policy_obs, torch.Tensor)
+  assert isinstance(critic_obs, torch.Tensor)
+  assert policy_obs.shape[1] == 15  # 3 features * 5 history
+  assert critic_obs.shape[1] == 3  # 3 features, no history
+
+
+def test_get_term_cfg_returns_resolved_config(mock_env):
+  """get_term_cfg should return resolved config with func as instance."""
+  term_cfg = ObservationTermCfg(func=ClassObsTerm, params={})
+
+  # Original config has func as a class.
+  assert inspect.isclass(term_cfg.func), "precondition: func should be a class"
+
+  cfg = {"actor": ObservationGroupCfg(terms={"obs1": term_cfg})}
+  manager = ObservationManager(cfg, mock_env)
+
+  # Original config should remain unchanged.
+  assert inspect.isclass(term_cfg.func), "original config should not be mutated"
+  assert inspect.isclass(manager.cfg["actor"].terms["obs1"].func), (
+    "manager.cfg should preserve original class"
+  )
+
+  # Resolved config should have func as an instance.
+  resolved_cfg = manager.get_term_cfg("actor", "obs1")
+  assert not inspect.isclass(resolved_cfg.func), (
+    "get_term_cfg should return resolved config with func as instance"
+  )
+  assert isinstance(resolved_cfg.func, ClassObsTerm), (
+    f"Expected ClassObsTerm instance, got {type(resolved_cfg.func)}"
+  )
+
+
+def test_scene_entity_cfg_in_params_not_mutated(device):
+  """SceneEntityCfg in params should not be mutated when resolved."""
+  # NOTE: 2 joints so selecting one won't optimize to slice(None).
+  xml = """
+  <mujoco>
+    <worldbody>
+      <body name="body1" pos="0 0 1">
+        <joint name="joint1" type="hinge" axis="0 0 1"/>
+        <geom type="sphere" size="0.1" mass="1"/>
+        <body name="body2" pos="0.2 0 0">
+          <joint name="joint2" type="hinge" axis="0 0 1"/>
+          <geom type="sphere" size="0.1" mass="1"/>
+        </body>
+      </body>
+    </worldbody>
+  </mujoco>
+  """
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(xml))
+  entity = Entity(entity_cfg)
+  model = entity.compile()
+
+  sim = Simulation(num_envs=2, cfg=SimulationCfg(), model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+
+  env = Mock()
+  env.num_envs = 2
+  env.device = device
+  env.max_episode_length_s = 10.0
+  env.scene = {"robot": entity}
+
+  # Select only joint1 --> joint_ids will mutate from slice(None) to [0].
+  asset_cfg = SceneEntityCfg(name="robot", joint_names=("joint1",))
+  original_joint_ids = asset_cfg.joint_ids  # slice(None) before resolve
+
+  def reward_func(env, asset_cfg):
+    del asset_cfg  # Unused.
+    return torch.ones(env.num_envs, device=env.device)
+
+  term_cfg = RewardTermCfg(
+    func=reward_func, params={"asset_cfg": asset_cfg}, weight=1.0
+  )
+
+  _ = RewardManager({"reward1": term_cfg}, env)
+
+  assert asset_cfg.joint_ids == original_joint_ids, (
+    f"SceneEntityCfg.joint_ids was mutated from {original_joint_ids} to "
+    f"{asset_cfg.joint_ids}"
+  )
diff --git a/tests/test_manipulation_commands.py b/tests/test_manipulation_commands.py
new file mode 100644
index 0000000..2de5d5e
--- /dev/null
+++ b/tests/test_manipulation_commands.py
@@ -0,0 +1,93 @@
+"""Tests for lifting command resample kinematics freshness.
+
+A timer-expiry resample runs inside command compute, after the step's single
+sim.forward(). The commands must refresh kinematics themselves so observations
+and the reward-path cache see post-teleport state.
+"""
+
+from types import SimpleNamespace
+from typing import TYPE_CHECKING, cast
+
+import pytest
+import torch
+from conftest import get_test_device, make_scene_and_sim
+
+from mjlab.tasks.manipulation.mdp.commands import (
+  LiftingCommandCfg,
+  MultiCubeLiftingCommandCfg,
+)
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+CUBE_XML = """
+<mujoco>
+  <worldbody>
+    <body name="cube">
+      <freejoint/>
+      <geom name="cube_geom" type="box" size="0.02 0.02 0.02" mass="0.1"/>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+def _make_env(device, entity_names):
+  scene, sim = make_scene_and_sim(
+    device, {name: CUBE_XML for name in entity_names}, sensors=(), num_envs=2
+  )
+  env = SimpleNamespace(scene=scene, sim=sim, num_envs=scene.num_envs, device=device)
+  return cast("ManagerBasedRlEnv", env)
+
+
+def _assert_kinematics_fresh(scene, sim, entity_name):
+  """xpos-derived root pos must match qpos after a compute-path resample."""
+  ent = scene[entity_name]
+  q_adr = ent.indexing.free_joint_q_adr
+  qpos_pos = sim.data.qpos[:, q_adr[:3]]
+  assert torch.allclose(ent.data.root_link_pos_w, qpos_pos, atol=1e-6)
+
+
+def test_lifting_resample_refreshes_kinematics(device):
+  env = _make_env(device, ("cube0",))
+  cfg = LiftingCommandCfg(entity_name="cube0", resampling_time_range=(0.001, 0.001))
+  term = cfg.build(env)
+
+  term.reset(env_ids=torch.arange(env.num_envs, device=device))
+  env.sim.forward()
+
+  counter = term.command_counter.clone()
+  term.compute(dt=1.0)  # Timer (1 ms) expires: teleports the object.
+  assert (term.command_counter > counter).all()
+
+  _assert_kinematics_fresh(env.scene, env.sim, "cube0")
+
+
+def test_multi_cube_resample_refreshes_kinematics_and_cache(device):
+  names = ("cube0", "cube1")
+  env = _make_env(device, names)
+  cfg = MultiCubeLiftingCommandCfg(
+    entity_names=names, resampling_time_range=(0.001, 0.001)
+  )
+  term = cfg.build(env)
+
+  term.reset(env_ids=torch.arange(env.num_envs, device=device))
+  env.sim.forward()
+
+  counter = term.command_counter.clone()
+  term.compute(dt=1.0)  # Timer (1 ms) expires: teleports all cubes.
+  assert (term.command_counter > counter).all()
+
+  for name in names:
+    _assert_kinematics_fresh(env.scene, env.sim, name)
+
+  # Reward-path cache serves the post-teleport position of the target cube.
+  all_pos = torch.stack([env.scene[n].data.root_link_pos_w for n in names])
+  arange = torch.arange(env.num_envs, device=device)
+  expected = all_pos[term.target_selection, arange]
+  assert torch.allclose(term.target_object_pos(), expected, atol=1e-6)
diff --git a/tests/test_manipulation_observations.py b/tests/test_manipulation_observations.py
new file mode 100644
index 0000000..d2de297
--- /dev/null
+++ b/tests/test_manipulation_observations.py
@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+from typing import TYPE_CHECKING, cast
+
+import mujoco
+import torch
+from conftest import get_test_device
+
+from mjlab.sensor import CameraSensorData
+from mjlab.tasks.manipulation.mdp.commands import MultiCubeLiftingCommand
+from mjlab.tasks.manipulation.mdp.observations import (
+  camera_segmentation,
+  camera_target_cube_mask,
+)
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+def _make_env(segmentation: torch.Tensor, target_geom_ids: torch.Tensor):
+  sensor = SimpleNamespace(data=CameraSensorData(segmentation=segmentation))
+
+  command = object.__new__(MultiCubeLiftingCommand)
+  command._padded_geom_ids = target_geom_ids
+  command.target_selection = torch.arange(
+    target_geom_ids.shape[0], device=target_geom_ids.device
+  )
+
+  command_manager = SimpleNamespace(get_term=lambda _: command)
+  return SimpleNamespace(
+    scene={"seg_cam": sensor},
+    command_manager=command_manager,
+  )
+
+
+def test_camera_segmentation_returns_bchw():
+  device = get_test_device()
+  geom = int(mujoco.mjtObj.mjOBJ_GEOM)
+  seg = torch.tensor(
+    [
+      [[[1, geom], [2, geom], [-1, -1]], [[3, geom], [4, geom], [-1, -1]]],
+      [[[5, geom], [6, geom], [-1, -1]], [[7, geom], [8, geom], [-1, -1]]],
+    ],
+    dtype=torch.int32,
+    device=device,
+  )
+  env = _make_env(seg, torch.tensor([[1], [7]], dtype=torch.int32, device=device))
+  env = cast("ManagerBasedRlEnv", env)
+
+  obs = camera_segmentation(env, "seg_cam")
+
+  assert obs.shape == (2, 2, 2, 3)
+  assert obs.dtype == torch.int32
+  assert torch.equal(obs[:, 0], seg[..., 0])
+  assert torch.equal(obs[:, 1], seg[..., 1])
+
+
+def test_camera_target_cube_mask_filters_to_geom_hits():
+  device = get_test_device()
+  geom = int(mujoco.mjtObj.mjOBJ_GEOM)
+  flex = int(mujoco.mjtObj.mjOBJ_FLEX)
+  seg = torch.tensor(
+    [
+      [[[3, geom], [3, flex], [0, geom]], [[-1, -1], [4, geom], [3, geom]]],
+      [[[5, geom], [7, flex], [5, geom]], [[7, geom], [-1, -1], [0, geom]]],
+    ],
+    dtype=torch.int32,
+    device=device,
+  )
+  env = _make_env(seg, torch.tensor([[3], [7]], dtype=torch.int32, device=device))
+  env = cast("ManagerBasedRlEnv", env)
+
+  mask = camera_target_cube_mask(env, "seg_cam", "lift_height")
+
+  expected = torch.tensor(
+    [
+      [[[1.0, 0.0, 0.0], [0.0, 0.0, 1.0]]],
+      [[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]],
+    ],
+    dtype=torch.float32,
+    device=device,
+  )
+  assert mask.shape == (2, 1, 2, 3)
+  assert torch.equal(mask, expected)
diff --git a/tests/test_metrics_manager.py b/tests/test_metrics_manager.py
new file mode 100644
index 0000000..648617a
--- /dev/null
+++ b/tests/test_metrics_manager.py
@@ -0,0 +1,359 @@
+"""Tests for metrics manager functionality."""
+
+from unittest.mock import Mock
+
+import pytest
+import torch
+
+from mjlab.managers.metrics_manager import (
+  MetricsManager,
+  MetricsTermCfg,
+  NullMetricsManager,
+)
+
+
+class SimpleTestMetric:
+  """A class-based metric that tracks state."""
+
+  def __init__(self, cfg: MetricsTermCfg, env):
+    self.call_count = torch.zeros(env.num_envs, device=env.device)
+
+  def __call__(self, env, **kwargs):
+    self.call_count += 1
+    return torch.ones(env.num_envs, device=env.device) * 0.5
+
+  def reset(self, env_ids: torch.Tensor | None = None, env=None):
+    if env_ids is not None and len(env_ids) > 0:
+      self.call_count[env_ids] = 0
+
+
+@pytest.fixture
+def mock_env():
+  env = Mock()
+  env.num_envs = 4
+  env.device = "cpu"
+  env.scene = {"robot": Mock()}
+  return env
+
+
+def test_episode_averages_and_reset(mock_env):
+  """Compute for N steps, reset a subset, verify averages and zeroing."""
+  cfg = {
+    "term": MetricsTermCfg(
+      func=lambda env: torch.ones(env.num_envs, device=env.device) * 0.5,
+      params={},
+    )
+  }
+  manager = MetricsManager(cfg, mock_env)
+
+  for _ in range(10):
+    manager.compute()
+
+  info = manager.reset(env_ids=torch.tensor([0, 1]))
+
+  # Each env: sum=5.0, count=10, avg=0.5. Mean across 2 reset envs = 0.5.
+  assert info["Episode_Metrics/term"].item() == pytest.approx(0.5)
+  # Reset envs zeroed; non-reset envs untouched.
+  assert manager._episode_sums["term"][0] == 0.0
+  assert manager._step_count[0] == 0
+  assert manager._episode_sums["term"][2] == pytest.approx(5.0)
+  assert manager._step_count[2] == 10
+
+
+def test_early_termination_uses_per_env_step_count(mock_env):
+  """Envs with different episode lengths get correct per-step averages."""
+  step = [0]
+
+  def step_dependent_metric(env):
+    step[0] += 1
+    return torch.full((env.num_envs,), float(step[0]), device=env.device)
+
+  cfg = {"m": MetricsTermCfg(func=step_dependent_metric, params={})}
+  manager = MetricsManager(cfg, mock_env)
+
+  # 4 steps for all envs: values are 1, 2, 3, 4.
+  for _ in range(4):
+    manager.compute()
+  # Env 0: sum=10, count=4. Reset it (env 1 keeps accumulating).
+  manager.reset(env_ids=torch.tensor([0]))
+
+  # 2 more steps: values are 5, 6.
+  for _ in range(2):
+    manager.compute()
+  # Env 0: sum=11, count=2, avg=5.5.
+  # Env 1: sum=21, count=6, avg=3.5.
+  info = manager.reset(env_ids=torch.tensor([0, 1]))
+  # Mean of [5.5, 3.5] = 4.5.
+  assert info["Episode_Metrics/m"].item() == pytest.approx(4.5)
+
+
+def test_class_based_metric_reset_targets_correct_envs(mock_env):
+  """Class-based term's reset() is called with the correct env_ids."""
+  cfg = {"term": MetricsTermCfg(func=SimpleTestMetric, params={})}
+  manager = MetricsManager(cfg, mock_env)
+  term = manager._class_term_cfgs[0].func
+
+  for _ in range(10):
+    manager.compute()
+
+  manager.reset(env_ids=torch.tensor([0, 2]))
+
+  assert term.call_count[0] == 0
+  assert term.call_count[1] == 10
+  assert term.call_count[2] == 0
+  assert term.call_count[3] == 10
+
+
+def test_null_metrics_manager(mock_env):
+  """NullMetricsManager doesn't crash and returns empty dict on reset."""
+  manager = NullMetricsManager()
+  manager.compute()
+  assert manager.reset(env_ids=torch.tensor([0])) == {}
+
+
+def test_none_terms_are_skipped(mock_env):
+  """None terms in config are skipped without error."""
+  cfg: dict[str, MetricsTermCfg | None] = {
+    "valid": MetricsTermCfg(
+      func=lambda env: torch.ones(env.num_envs, device=env.device),
+      params={},
+    ),
+    "skipped": None,
+  }
+  manager = MetricsManager(cfg, mock_env)  # type: ignore[arg-type]
+  assert manager._term_names == ["valid"]
+
+
+def test_per_substep_averaging(mock_env):
+  """Substep terms are averaged across substeps; step terms evaluated once."""
+  substep_call = [0]
+
+  def rising_metric(env):
+    substep_call[0] += 1
+    return torch.full((env.num_envs,), float(substep_call[0]), device=env.device)
+
+  cfg = {
+    "step_term": MetricsTermCfg(
+      func=lambda env: torch.ones(env.num_envs, device=env.device) * 2.0,
+      params={},
+    ),
+    "substep_term": MetricsTermCfg(func=rising_metric, params={}, per_substep=True),
+  }
+  manager = MetricsManager(cfg, mock_env)
+
+  for _ in range(2):  # 2 env steps
+    for _ in range(4):  # 4 substeps each
+      manager.compute_substep()
+    manager.compute()
+
+  info = manager.reset(env_ids=torch.tensor([0]))
+  assert info["Episode_Metrics/step_term"].item() == pytest.approx(2.0)
+  # Substeps: step 0 -> [1,2,3,4] avg=2.5; step 1 -> [5,6,7,8] avg=6.5.
+  # Episode avg = (2.5 + 6.5) / 2 = 4.5.  A broken single-eval path
+  # would give (1 + 2) / 2 = 1.5.
+  assert info["Episode_Metrics/substep_term"].item() == pytest.approx(4.5)
+
+
+def test_substep_reset_zeroes_accumulators(mock_env):
+  """Reset zeroes substep accumulators for the given env_ids."""
+  cfg = {
+    "sub": MetricsTermCfg(
+      func=lambda env: torch.ones(env.num_envs, device=env.device),
+      params={},
+      per_substep=True,
+    ),
+  }
+  manager = MetricsManager(cfg, mock_env)
+
+  # Accumulate some substep values without calling compute().
+  for _ in range(3):
+    manager.compute_substep()
+
+  # Reset env 0 -- its substep accum should be zeroed.
+  manager.reset(env_ids=torch.tensor([0]))
+  assert manager._substep_accum[0][0].item() == 0.0
+  # Env 1 still has its accumulated value.
+  assert manager._substep_accum[0][1].item() == pytest.approx(3.0)
+
+
+def test_reduce_last_reports_final_step_value(mock_env):
+  """reduce='last' reports the last step's value, not the episode average."""
+  step = [0]
+
+  def rising_metric(env):
+    step[0] += 1
+    return torch.full((env.num_envs,), float(step[0]), device=env.device)
+
+  cfg = {"term": MetricsTermCfg(func=rising_metric, params={}, reduce="last")}
+  manager = MetricsManager(cfg, mock_env)
+
+  for _ in range(4):
+    manager.compute()
+
+  info = manager.reset(env_ids=torch.tensor([0]))
+
+  # Values were 1, 2, 3, 4. Mean would be 2.5; last should be 4.
+  assert info["Episode_Metrics/term"].item() == pytest.approx(4.0)
+
+
+def test_reduce_mean_and_last_coexist(mock_env):
+  """Mixed reduce modes in the same manager report correctly."""
+  step = [0]
+
+  def rising_metric(env):
+    step[0] += 1
+    return torch.full((env.num_envs,), float(step[0]), device=env.device)
+
+  cfg = {
+    "mean_term": MetricsTermCfg(func=rising_metric, params={}, reduce="mean"),
+    "last_term": MetricsTermCfg(func=rising_metric, params={}, reduce="last"),
+  }
+  manager = MetricsManager(cfg, mock_env)
+
+  for _ in range(3):
+    manager.compute()
+
+  info = manager.reset(env_ids=torch.tensor([0]))
+
+  # mean_term sees steps 1, 3, 5 (odd calls); episode avg = 3.0.
+  # last_term sees steps 2, 4, 6 (even calls); last value = 6.0.
+  assert info["Episode_Metrics/mean_term"].item() == pytest.approx(3.0)
+  assert info["Episode_Metrics/last_term"].item() == pytest.approx(6.0)
+
+
+def test_metrics_step_shape_validation_rejects_bad_compute_output(mock_env):
+  """Step metrics must return one scalar per environment."""
+  cfg = {"bad": MetricsTermCfg(func=lambda env: torch.ones(env.num_envs, 1))}
+  manager = MetricsManager(cfg, mock_env)
+  with pytest.raises(ValueError, match="MetricsManager term 'bad'.*expected \\(4,\\)"):
+    manager.compute()
+
+
+def test_metrics_substep_shape_validation_rejects_bad_compute_output(mock_env):
+  """Substep metrics must return one scalar per environment."""
+  cfg = {
+    "bad": MetricsTermCfg(
+      func=lambda env: torch.ones(env.num_envs, 1), per_substep=True
+    )
+  }
+  manager = MetricsManager(cfg, mock_env)
+  with pytest.raises(ValueError, match="MetricsManager term 'bad'.*expected \\(4,\\)"):
+    manager.compute_substep()
+
+
+def test_reduce_max_reports_episode_peak(mock_env):
+  """reduce='max' reports the highest value seen during the episode."""
+  step = [0]
+
+  def rising_then_falling(env):
+    step[0] += 1
+    val = 5.0 - abs(step[0] - 3)  # values: 3, 4, 5, 4, 3
+    return torch.full((env.num_envs,), val, device=env.device)
+
+  cfg = {"term": MetricsTermCfg(func=rising_then_falling, params={}, reduce="max")}
+  manager = MetricsManager(cfg, mock_env)
+
+  for _ in range(5):
+    manager.compute()
+
+  info = manager.reset(env_ids=torch.tensor([0]))
+
+  assert info["Episode_Metrics/term"].item() == pytest.approx(5.0)
+
+
+def test_reduce_max_reset_clears_to_neg_inf(mock_env):
+  """After reset, max tracking restarts from -inf."""
+  cfg = {
+    "term": MetricsTermCfg(
+      func=lambda env: torch.ones(env.num_envs, device=env.device) * 10.0,
+      params={},
+      reduce="max",
+    )
+  }
+  manager = MetricsManager(cfg, mock_env)
+
+  manager.compute()
+  manager.reset(env_ids=torch.tensor([0]))
+
+  # After reset, the max buffer for env 0 should be -inf.
+  assert manager._episode_max["term"][0].item() == float("-inf")
+  # Env 1 was not reset, so it keeps its max.
+  assert manager._episode_max["term"][1].item() == pytest.approx(10.0)
+
+
+def test_reduce_max_coexists_with_mean_and_last(mock_env):
+  """All three reduce modes work correctly in the same manager."""
+  step = [0]
+
+  def rising_metric(env):
+    step[0] += 1
+    return torch.full((env.num_envs,), float(step[0]), device=env.device)
+
+  cfg = {
+    "mean_term": MetricsTermCfg(func=rising_metric, params={}, reduce="mean"),
+    "last_term": MetricsTermCfg(func=rising_metric, params={}, reduce="last"),
+    "max_term": MetricsTermCfg(func=rising_metric, params={}, reduce="max"),
+  }
+  manager = MetricsManager(cfg, mock_env)
+
+  for _ in range(3):
+    manager.compute()
+
+  info = manager.reset(env_ids=torch.tensor([0]))
+
+  # mean_term sees 1, 4, 7; avg = 4.0
+  assert info["Episode_Metrics/mean_term"].item() == pytest.approx(4.0)
+  # last_term sees 2, 5, 8; last = 8.0
+  assert info["Episode_Metrics/last_term"].item() == pytest.approx(8.0)
+  # max_term sees 3, 6, 9; max = 9.0
+  assert info["Episode_Metrics/max_term"].item() == pytest.approx(9.0)
+
+
+def test_reduce_max_with_per_substep(mock_env):
+  """reduce='max' with per_substep tracks the max of step-averaged values."""
+  substep_call = [0]
+
+  def rising_metric(env):
+    substep_call[0] += 1
+    return torch.full((env.num_envs,), float(substep_call[0]), device=env.device)
+
+  cfg = {
+    "sub_max": MetricsTermCfg(
+      func=rising_metric, params={}, per_substep=True, reduce="max"
+    ),
+  }
+  manager = MetricsManager(cfg, mock_env)
+
+  # Step 0: substeps [1, 2] -> avg = 1.5
+  for _ in range(2):
+    manager.compute_substep()
+  manager.compute()
+
+  # Step 1: substeps [3, 4] -> avg = 3.5
+  for _ in range(2):
+    manager.compute_substep()
+  manager.compute()
+
+  info = manager.reset(env_ids=torch.tensor([0]))
+
+  # Max of step averages: max(1.5, 3.5) = 3.5
+  assert info["Episode_Metrics/sub_max"].item() == pytest.approx(3.5)
+
+
+def test_no_substep_terms_no_overhead(mock_env):
+  """When no per_substep terms exist, compute_substep is a no-op."""
+  cfg = {
+    "step_only": MetricsTermCfg(
+      func=lambda env: torch.ones(env.num_envs, device=env.device),
+      params={},
+    ),
+  }
+  manager = MetricsManager(cfg, mock_env)
+
+  # Should not raise or change state.
+  manager.compute_substep()
+  assert manager._substep_count == 0
+
+  manager.compute()
+  info = manager.reset(env_ids=torch.tensor([0]))
+  assert info["Episode_Metrics/step_only"].item() == pytest.approx(1.0)
diff --git a/tests/test_nan_guard.py b/tests/test_nan_guard.py
new file mode 100644
index 0000000..06b4b48
--- /dev/null
+++ b/tests/test_nan_guard.py
@@ -0,0 +1,409 @@
+"""Tests for NaN guard functionality."""
+
+import tempfile
+from pathlib import Path
+
+import mujoco
+import numpy as np
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.sim.sim import Simulation, SimulationCfg
+from mjlab.utils.nan_guard import NanGuardCfg
+
+
+@pytest.fixture
+def simple_model():
+  """Create a simple MuJoCo model for testing."""
+  xml = """
+  <mujoco>
+    <worldbody>
+      <body>
+        <freejoint/>
+        <geom type="box" size="0.1 0.1 0.1"/>
+      </body>
+    </worldbody>
+  </mujoco>
+  """
+  spec = mujoco.MjSpec.from_string(xml)
+  return spec.compile()
+
+
+@pytest.fixture
+def mocap_model():
+  """Create a model with a mocap body and a freejoint body."""
+  xml = """
+  <mujoco>
+    <worldbody>
+      <body name="mocap_body" mocap="true">
+        <geom type="sphere" size="0.05"/>
+      </body>
+      <body name="free_body">
+        <freejoint/>
+        <geom type="box" size="0.1 0.1 0.1"/>
+      </body>
+    </worldbody>
+  </mujoco>
+  """
+  spec = mujoco.MjSpec.from_string(xml)
+  return spec.compile()
+
+
+def test_nan_guard_disabled_by_default(simple_model):
+  """NaN guard should be disabled by default with no overhead."""
+  cfg = SimulationCfg()
+  sim = Simulation(num_envs=2, cfg=cfg, model=simple_model, device=get_test_device())
+
+  assert not sim.nan_guard.enabled
+  sim.step()  # Should not trigger any capture.
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="Likely bug on CPU MjWarp")
+def test_nan_guard_captures_and_dumps_on_nan(simple_model):
+  """NaN guard should capture states and dump when NaN detected."""
+  with tempfile.TemporaryDirectory() as tmpdir:
+    cfg = SimulationCfg(
+      nan_guard=NanGuardCfg(
+        enabled=True,
+        buffer_size=5,
+        output_dir=tmpdir,
+        max_envs_to_dump=2,
+      )
+    )
+    sim = Simulation(num_envs=4, cfg=cfg, model=simple_model, device=get_test_device())
+
+    # Run a few steps to populate buffer.
+    for _ in range(3):
+      sim.step()
+
+    # Inject NaN into environment 1.
+    sim.data.qpos[1, 0] = float("nan")
+
+    # Next step should trigger dump.
+    sim.step()
+
+    # Check that timestamped dump file was created.
+    dump_files = [
+      f for f in Path(tmpdir).glob("nan_dump_*.npz") if "latest" not in f.name
+    ]
+    assert len(dump_files) == 1
+
+    # Load and inspect the dump.
+    dump = np.load(dump_files[0], allow_pickle=True)
+    metadata = dump["_metadata"].item()
+
+    assert metadata["num_envs_total"] == 4
+    assert metadata["num_envs_dumped"] == 1
+    assert 1 in metadata["nan_env_ids"]
+    assert metadata["buffer_size"] == 4
+
+    # Check that states were captured.
+    assert "states_step_000000" in dump
+    assert "states_step_000001" in dump
+    assert "states_step_000002" in dump
+    assert "states_step_000003" in dump
+
+    # Verify state shape: (num_envs_dumped, state_size).
+    state = dump["states_step_000000"]
+    assert state.shape[0] == 1
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="Likely bug on CPU MjWarp")
+def test_nan_guard_detects_correct_env_ids(simple_model):
+  """NaN guard should correctly identify which environments have NaN/Inf."""
+  with tempfile.TemporaryDirectory() as tmpdir:
+    cfg = SimulationCfg(
+      nan_guard=NanGuardCfg(enabled=True, buffer_size=5, output_dir=tmpdir)
+    )
+    sim = Simulation(num_envs=10, cfg=cfg, model=simple_model, device=get_test_device())
+
+    # Run a few steps to populate buffer.
+    for _ in range(3):
+      sim.step()
+
+    # Inject NaN/Inf into environments 2, 5, and 7 (in state variables).
+    sim.data.qpos[2, 0] = float("nan")
+    sim.data.qvel[5, 1] = float("nan")
+    sim.data.qvel[7, 2] = float("inf")
+
+    # Next step should trigger dump.
+    sim.step()
+
+    # Load and inspect the dump.
+    dump_files = [
+      f for f in Path(tmpdir).glob("nan_dump_*.npz") if "latest" not in f.name
+    ]
+    assert len(dump_files) == 1
+
+    dump = np.load(dump_files[0], allow_pickle=True)
+    metadata = dump["_metadata"].item()
+
+    # Should detect exactly the environments with NaN/Inf.
+    nan_env_ids = set(metadata["nan_env_ids"])
+    assert nan_env_ids == {2, 5, 7}, f"Expected {{2, 5, 7}}, got {nan_env_ids}"
+
+
+def test_nan_guard_saves_model(simple_model):
+  """NaN guard should save model file alongside state dump."""
+  with tempfile.TemporaryDirectory() as tmpdir:
+    cfg = SimulationCfg(
+      nan_guard=NanGuardCfg(enabled=True, buffer_size=5, output_dir=tmpdir)
+    )
+    sim = Simulation(num_envs=2, cfg=cfg, model=simple_model, device=get_test_device())
+
+    # Inject NaN and trigger dump.
+    sim.data.qpos[0, 0] = float("nan")
+    sim.step()
+
+    # Check that both dump and model files were created.
+    dump_files = [
+      f for f in Path(tmpdir).glob("nan_dump_*.npz") if "latest" not in f.name
+    ]
+    model_files = [
+      f for f in Path(tmpdir).glob("model_*.mjb") if "latest" not in f.name
+    ]
+    assert len(dump_files) == 1
+    assert len(model_files) == 1
+
+    # Verify model file can be loaded.
+    dump = np.load(dump_files[0], allow_pickle=True)
+    metadata = dump["_metadata"].item()
+    model_path = Path(tmpdir) / metadata["model_file"]
+    assert model_path.exists()
+
+    # Load model and verify it's valid.
+    loaded_model = mujoco.MjModel.from_binary_path(str(model_path))
+    assert loaded_model.nq == simple_model.nq
+    assert loaded_model.nv == simple_model.nv
+
+
+@pytest.mark.slow
+def test_nan_guard_with_complex_model():
+  """NaN guard should work with complex robot model."""
+  from mjlab.scene import Scene
+  from mjlab.tasks.velocity.config.go1.env_cfgs import unitree_go1_rough_env_cfg
+
+  scene = Scene(unitree_go1_rough_env_cfg().scene, device=get_test_device())
+  model = scene.compile()
+
+  with tempfile.TemporaryDirectory() as tmpdir:
+    cfg = SimulationCfg(
+      nan_guard=NanGuardCfg(enabled=True, buffer_size=3, output_dir=tmpdir)
+    )
+    sim = Simulation(num_envs=2, cfg=cfg, model=model, device=get_test_device())
+
+    # Run a few steps.
+    for _ in range(2):
+      sim.step()
+
+    # Inject NaN and trigger dump.
+    sim.data.qpos[0, 0] = float("nan")
+    sim.step()
+
+    # Verify dump and model files were created.
+    dump_files = [
+      f for f in Path(tmpdir).glob("nan_dump_*.npz") if "latest" not in f.name
+    ]
+    model_files = [
+      f for f in Path(tmpdir).glob("model_*.mjb") if "latest" not in f.name
+    ]
+    assert len(dump_files) == 1
+    assert len(model_files) == 1
+
+    # Load the saved model and verify it matches.
+    dump = np.load(dump_files[0], allow_pickle=True)
+    metadata = dump["_metadata"].item()
+    model_path = Path(tmpdir) / metadata["model_file"]
+
+    loaded_model = mujoco.MjModel.from_binary_path(str(model_path))
+    assert loaded_model.nq == model.nq
+    assert loaded_model.nv == model.nv
+    assert loaded_model.nu == model.nu  # Check actuators too
+
+    # Verify we can create MjData and restore a state.
+    loaded_data = mujoco.MjData(loaded_model)
+    state = dump["states_step_000000"][0]
+    state_spec = metadata.get("state_spec", mujoco.mjtState.mjSTATE_PHYSICS.value)
+    mujoco.mj_setState(loaded_model, loaded_data, state, state_spec)
+    mujoco.mj_forward(loaded_model, loaded_data)
+
+    # Data should be valid (no NaN in derived quantities after forward).
+    assert not np.isnan(loaded_data.qpos).any()
+
+
+def test_nan_guard_only_dumps_once(simple_model):
+  """NaN guard should only dump once per training run."""
+  with tempfile.TemporaryDirectory() as tmpdir:
+    cfg = SimulationCfg(
+      nan_guard=NanGuardCfg(enabled=True, buffer_size=5, output_dir=tmpdir)
+    )
+    sim = Simulation(num_envs=2, cfg=cfg, model=simple_model, device=get_test_device())
+
+    # Inject NaN.
+    sim.data.qpos[0, 0] = float("nan")
+    sim.step()
+
+    # Should have exactly one timestamped dump.
+    dump_files = [
+      f for f in Path(tmpdir).glob("nan_dump_*.npz") if "latest" not in f.name
+    ]
+    assert len(dump_files) == 1
+
+    # Inject another NaN.
+    sim.data.qpos[1, 0] = float("nan")
+    sim.step()
+
+    # Should still have only one timestamped dump.
+    dump_files = [
+      f for f in Path(tmpdir).glob("nan_dump_*.npz") if "latest" not in f.name
+    ]
+    assert len(dump_files) == 1
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="Likely bug on CPU MjWarp")
+def test_nan_guard_respects_buffer_size(simple_model):
+  """NaN guard should only keep last K states in buffer."""
+  with tempfile.TemporaryDirectory() as tmpdir:
+    cfg = SimulationCfg(
+      nan_guard=NanGuardCfg(enabled=True, buffer_size=3, output_dir=tmpdir)
+    )
+    sim = Simulation(num_envs=2, cfg=cfg, model=simple_model, device=get_test_device())
+
+    # Run 10 steps.
+    for _ in range(10):
+      sim.step()
+
+    # Inject NaN.
+    sim.data.qpos[0, 0] = float("nan")
+    sim.step()
+
+    # Load dump.
+    dump_files = [
+      f for f in Path(tmpdir).glob("nan_dump_*.npz") if "latest" not in f.name
+    ]
+    dump = np.load(dump_files[0], allow_pickle=True)
+
+    # Should only have 3 states (buffer size).
+    state_keys = [k for k in dump.keys() if k.startswith("states_step_")]
+    assert len(state_keys) == 3
+
+    # Should be the last 3 steps (steps 8, 9, 10 where step 10 has NaN).
+    assert "states_step_000008" in dump
+    assert "states_step_000009" in dump
+    assert "states_step_000010" in dump
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="Likely bug on CPU MjWarp")
+def test_nan_guard_captures_high_indexed_envs(simple_model):
+  """NaN guard should capture NaN in high-indexed environments beyond max_envs_to_dump."""
+  with tempfile.TemporaryDirectory() as tmpdir:
+    cfg = SimulationCfg(
+      nan_guard=NanGuardCfg(
+        enabled=True, buffer_size=5, output_dir=tmpdir, max_envs_to_dump=3
+      )
+    )
+    sim = Simulation(num_envs=10, cfg=cfg, model=simple_model, device=get_test_device())
+
+    for _ in range(3):
+      sim.step()
+
+    sim.data.qpos[7, 0] = float("nan")
+    sim.step()
+
+    dump_files = [
+      f for f in Path(tmpdir).glob("nan_dump_*.npz") if "latest" not in f.name
+    ]
+    assert len(dump_files) == 1
+
+    dump = np.load(dump_files[0], allow_pickle=True)
+    metadata = dump["_metadata"].item()
+
+    assert 7 in metadata["nan_env_ids"]
+    assert 7 in metadata["dumped_env_ids"]
+    assert metadata["num_envs_total"] == 10
+    assert metadata["num_envs_dumped"] == 1
+
+    state = dump["states_step_000000"]
+    assert state.shape[0] == 1
+
+
+def test_nan_guard_creates_latest_symlinks(simple_model):
+  """NaN guard should create latest symlinks that work correctly."""
+  with tempfile.TemporaryDirectory() as tmpdir:
+    cfg = SimulationCfg(
+      nan_guard=NanGuardCfg(enabled=True, buffer_size=5, output_dir=tmpdir)
+    )
+    sim = Simulation(num_envs=2, cfg=cfg, model=simple_model, device=get_test_device())
+
+    sim.data.qpos[0, 0] = float("nan")
+    sim.step()
+
+    latest_dump = Path(tmpdir) / "nan_dump_latest.npz"
+    latest_model = Path(tmpdir) / "model_latest.mjb"
+
+    # Verify symlinks exist.
+    assert latest_dump.exists()
+    assert latest_model.exists()
+    assert latest_dump.is_symlink()
+    assert latest_model.is_symlink()
+
+    # Load via symlink and verify it works.
+    dump = np.load(latest_dump, allow_pickle=True)
+    metadata = dump["_metadata"].item()
+
+    # Metadata should reference the timestamped model file.
+    assert metadata["model_file"].startswith("model_")
+    assert metadata["model_file"].endswith(".mjb")
+    assert (Path(tmpdir) / metadata["model_file"]).exists()
+
+    # Loading via symlink should work.
+    loaded_model = mujoco.MjModel.from_binary_path(str(latest_model))
+    assert loaded_model.nq == simple_model.nq
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="Likely bug on CPU MjWarp")
+def test_nan_guard_captures_mocap_state(mocap_model):
+  """NaN guard should capture and restore mocap body poses."""
+  with tempfile.TemporaryDirectory() as tmpdir:
+    cfg = SimulationCfg(
+      nan_guard=NanGuardCfg(enabled=True, buffer_size=5, output_dir=tmpdir)
+    )
+    sim = Simulation(num_envs=2, cfg=cfg, model=mocap_model, device=get_test_device())
+
+    # Set a known mocap position before stepping.
+    sim.data.mocap_pos[0, 0] = torch.tensor([1.0, 2.0, 3.0], device=get_test_device())
+
+    # Run a few steps.
+    for _ in range(3):
+      sim.step()
+
+    # Inject NaN to trigger dump.
+    sim.data.qpos[0, 0] = float("nan")
+    sim.step()
+
+    # Load dump.
+    dump_files = [
+      f for f in Path(tmpdir).glob("nan_dump_*.npz") if "latest" not in f.name
+    ]
+    assert len(dump_files) == 1
+
+    dump = np.load(dump_files[0], allow_pickle=True)
+    metadata = dump["_metadata"].item()
+
+    # Metadata should include state_spec with mocap flags.
+    assert "state_spec" in metadata
+    state_spec = metadata["state_spec"]
+    assert state_spec & mujoco.mjtState.mjSTATE_MOCAP_POS.value
+    assert state_spec & mujoco.mjtState.mjSTATE_MOCAP_QUAT.value
+
+    # State size should be larger than physics-only.
+    physics_size = mujoco.mj_stateSize(mocap_model, mujoco.mjtState.mjSTATE_PHYSICS)
+    assert metadata["state_size"] > physics_size
+
+    # Restore a state and verify mocap data round-trips.
+    loaded_data = mujoco.MjData(mocap_model)
+    state = dump["states_step_000000"][0]
+    mujoco.mj_setState(mocap_model, loaded_data, state, state_spec)
+    assert loaded_data.mocap_pos.shape == (1, 3)
+    np.testing.assert_allclose(loaded_data.mocap_pos[0], [1.0, 2.0, 3.0], atol=1e-5)
diff --git a/tests/test_native_viewer_actions.py b/tests/test_native_viewer_actions.py
new file mode 100644
index 0000000..6af3b3d
--- /dev/null
+++ b/tests/test_native_viewer_actions.py
@@ -0,0 +1,40 @@
+"""Tests for native viewer custom action dispatch."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+from mjlab.viewer.base import ViewerAction
+from mjlab.viewer.native.viewer import NativeMujocoViewer
+
+
+def _make_viewer(num_envs: int = 3) -> NativeMujocoViewer:
+  env = MagicMock()
+  env.cfg.viewer.env_idx = 0
+  env.unwrapped.num_envs = num_envs
+  return NativeMujocoViewer(env, MagicMock())
+
+
+def test_toggle_actions_dispatch_by_action_enum():
+  v = _make_viewer()
+
+  assert not v._show_plots
+  assert v._handle_custom_action(ViewerAction.TOGGLE_PLOTS, None)
+  assert v._show_plots
+
+  assert v._show_debug_vis
+  assert v._handle_custom_action(ViewerAction.TOGGLE_DEBUG_VIS, None)
+  assert not v._show_debug_vis
+
+  assert not v._show_all_envs
+  assert v._handle_custom_action(ViewerAction.TOGGLE_SHOW_ALL_ENVS, None)
+  assert v._show_all_envs
+
+
+def test_prev_next_env_actions_wrap_and_succeed():
+  v = _make_viewer(num_envs=3)
+  v.env_idx = 0
+  assert v._handle_custom_action(ViewerAction.PREV_ENV, None)
+  assert v.env_idx == 2
+  assert v._handle_custom_action(ViewerAction.NEXT_ENV, None)
+  assert v.env_idx == 0
diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py
new file mode 100644
index 0000000..75499df
--- /dev/null
+++ b/tests/test_notebooks.py
@@ -0,0 +1,127 @@
+"""Validate that notebook cells import only symbols that exist in mjlab.
+
+The cartpole tutorial notebook writes Python files via ``%%writefile`` cells
+and imports directly from ``mjlab`` in others. When a public API is renamed
+or removed, those references silently rot until a user runs the notebook.
+This test parses each code cell, finds ``from mjlab... import X`` statements,
+and verifies that ``X`` is actually importable.
+
+Modules that the notebook itself creates (via ``%%writefile`` into the mjlab
+source tree) are skipped, since they don't exist until the notebook runs.
+"""
+
+from __future__ import annotations
+
+import ast
+import importlib
+import json
+import re
+from pathlib import Path
+
+import pytest
+
+NOTEBOOKS_DIR = Path(__file__).parent.parent / "notebooks"
+
+# Match "%%writefile /content/mjlab/src/mjlab/foo/bar.py" style targets that
+# land inside the mjlab package.
+_WRITEFILE_MJLAB_RE = re.compile(
+  r"^\s*%%writefile\s+\S*?/src/(mjlab(?:/[\w/]+)+)\.py\s*$"
+)
+
+
+def _extract_python_source(cell_source: str) -> str | None:
+  """Return Python source for a cell, or None if it has no Python to parse.
+
+  Handles ``%%writefile path.py`` cells by returning their body (only when the
+  target is a ``.py`` file; XML/YAML/etc. writefiles are skipped). Strips
+  shell escapes (``!...``) and line magics (``%...``).
+  """
+  lines = cell_source.splitlines()
+  if lines and lines[0].lstrip().startswith("%%writefile"):
+    target = lines[0].split(maxsplit=1)[1] if len(lines[0].split()) > 1 else ""
+    if not target.endswith(".py"):
+      return None
+    return "\n".join(lines[1:])
+  # Skip other cell magics (%%bash, %%html, etc.) entirely.
+  if lines and lines[0].lstrip().startswith("%%"):
+    return None
+  kept = [ln for ln in lines if not ln.lstrip().startswith(("!", "%"))]
+  return "\n".join(kept)
+
+
+def _iter_mjlab_imports(source: str):
+  """Yield (module, name) for every ``from mjlab... import name`` in source."""
+  tree = ast.parse(source)
+  for node in ast.walk(tree):
+    if isinstance(node, ast.ImportFrom) and node.module:
+      if node.module == "mjlab" or node.module.startswith("mjlab."):
+        for alias in node.names:
+          yield node.module, alias.name
+
+
+def _collect_written_modules(nb: dict) -> set[str]:
+  """Return the set of mjlab modules the notebook creates via %%writefile."""
+  written: set[str] = set()
+  for cell in nb.get("cells", []):
+    if cell.get("cell_type") != "code":
+      continue
+    source = "".join(cell.get("source", []))
+    first_line = source.splitlines()[0] if source else ""
+    match = _WRITEFILE_MJLAB_RE.match(first_line)
+    if match:
+      written.add(match.group(1).replace("/", "."))
+  return written
+
+
+def _collect_notebook_imports(path: Path):
+  """Return (imports, written_modules) where imports is a list of
+  (cell_index, module, name) tuples for every ``from mjlab... import`` in the
+  notebook, and written_modules is the set of mjlab modules the notebook
+  creates itself.
+  """
+  nb = json.loads(path.read_text())
+  written = _collect_written_modules(nb)
+  imports = []
+  for idx, cell in enumerate(nb.get("cells", [])):
+    if cell.get("cell_type") != "code":
+      continue
+    source = "".join(cell.get("source", []))
+    python_src = _extract_python_source(source)
+    if not python_src or not python_src.strip():
+      continue
+    try:
+      cell_imports = list(_iter_mjlab_imports(python_src))
+    except SyntaxError as e:
+      pytest.fail(f"Cell {idx} in {path.name} has invalid Python syntax: {e}")
+    for module, name in cell_imports:
+      imports.append((idx, module, name))
+  return imports, written
+
+
+@pytest.mark.parametrize("notebook_path", sorted(NOTEBOOKS_DIR.glob("*.ipynb")))
+def test_notebook_mjlab_imports_resolve(notebook_path: Path) -> None:
+  """Every ``from mjlab... import X`` in a notebook must resolve."""
+  imports, written_modules = _collect_notebook_imports(notebook_path)
+  failures = []
+  for cell_idx, module, name in imports:
+    # Skip modules the notebook writes itself; they don't exist until runtime.
+    if module in written_modules or any(
+      module.startswith(w + ".") for w in written_modules
+    ):
+      continue
+    try:
+      mod = importlib.import_module(module)
+    except ImportError as e:
+      failures.append(
+        f"cell {cell_idx}: `from {module} import {name}` failed to import module: {e}"
+      )
+      continue
+    if not hasattr(mod, name):
+      failures.append(
+        f"cell {cell_idx}: `from {module} import {name}` — "
+        f"'{name}' is not exposed by '{module}'"
+      )
+  if failures:
+    pytest.fail(
+      f"Stale mjlab imports in {notebook_path.name}:\n  " + "\n  ".join(failures)
+    )
diff --git a/tests/test_observation_delay.py b/tests/test_observation_delay.py
new file mode 100644
index 0000000..9c6ff99
--- /dev/null
+++ b/tests/test_observation_delay.py
@@ -0,0 +1,660 @@
+"""Tests for observation delay functionality."""
+
+from unittest.mock import Mock
+
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.managers.observation_manager import (
+  ObservationGroupCfg,
+  ObservationManager,
+  ObservationTermCfg,
+)
+
+
+@pytest.fixture
+def device():
+  """Test device fixture."""
+  return get_test_device()
+
+
+@pytest.fixture
+def mock_env(device):
+  """Create a mock environment."""
+  env = Mock()
+  env.num_envs = 4
+  env.device = device
+  env.step_dt = 0.02
+  return env
+
+
+@pytest.fixture
+def simple_obs_func(device):
+  """Create a simple observation function that returns a counter."""
+  counter = {"value": 0}
+
+  def obs_func(env):
+    counter["value"] += 1
+    return torch.full((env.num_envs, 3), float(counter["value"]), device=device)
+
+  return obs_func
+
+
+##
+# Basic delay tests.
+##
+
+
+def test_no_delay_by_default(mock_env, simple_obs_func):
+  """Test that observations work without delay (default behavior)."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(func=simple_obs_func, params={}),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  assert manager.group_obs_dim["actor"] == (3,)
+
+  obs = manager.compute(update_history=True)
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  assert policy_obs.shape == (4, 3)
+
+
+def test_constant_delay(mock_env, simple_obs_func, device):
+  """Test observation with constant delay (min_lag = max_lag = 2)."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func, params={}, delay_min_lag=2, delay_max_lag=2
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  # Note: counter is incremented during _prepare_terms (value=1).
+
+  # First compute uses value=2.
+  # Delay: lag=2 sampled, buffer only has 1 frame, clamped to lag=0, returns 2.
+  obs1 = manager.compute(update_history=True)
+  policy_obs1 = obs1["actor"]
+  assert isinstance(policy_obs1, torch.Tensor)
+  assert torch.allclose(policy_obs1[0], torch.full((3,), 2.0, device=device))
+
+  # Second compute uses value=3.
+  # Delay: lag=2, buffer has 2 frames, clamped to lag=1, returns 2.
+  obs2 = manager.compute(update_history=True)
+  policy_obs2 = obs2["actor"]
+  assert isinstance(policy_obs2, torch.Tensor)
+  assert torch.allclose(policy_obs2[0], torch.full((3,), 2.0, device=device))
+
+  # Third compute uses value=4.
+  # Delay: lag=2, buffer full (3 frames), returns value from 2 steps ago = 2.
+  obs3 = manager.compute(update_history=True)
+  policy_obs3 = obs3["actor"]
+  assert isinstance(policy_obs3, torch.Tensor)
+  assert torch.allclose(policy_obs3[0], torch.full((3,), 2.0, device=device))
+
+  # Fourth compute uses value=5.
+  # Delay: lag=2, returns value from 2 steps ago = 3.
+  obs4 = manager.compute(update_history=True)
+  policy_obs4 = obs4["actor"]
+  assert isinstance(policy_obs4, torch.Tensor)
+  assert torch.allclose(policy_obs4[0], torch.full((3,), 3.0, device=device))
+
+  # Fifth compute uses value=6.
+  # Delay: lag=2, returns value from 2 steps ago = 4.
+  obs5 = manager.compute(update_history=True)
+  policy_obs5 = obs5["actor"]
+  assert isinstance(policy_obs5, torch.Tensor)
+  assert torch.allclose(policy_obs5[0], torch.full((3,), 4.0, device=device))
+
+
+def test_zero_delay_returns_current(mock_env, simple_obs_func, device):
+  """Test that delay with min_lag=max_lag=0 returns current observation."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func, params={}, delay_min_lag=0, delay_max_lag=0
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  # First compute uses value=2 (counter at 1 after _prepare_terms).
+  obs1 = manager.compute(update_history=True)
+  policy_obs1 = obs1["actor"]
+  assert isinstance(policy_obs1, torch.Tensor)
+  assert torch.allclose(policy_obs1[0], torch.full((3,), 2.0, device=device))
+
+  # Second compute uses value=3.
+  obs2 = manager.compute(update_history=True)
+  policy_obs2 = obs2["actor"]
+  assert isinstance(policy_obs2, torch.Tensor)
+  assert torch.allclose(policy_obs2[0], torch.full((3,), 3.0, device=device))
+
+
+def test_lag_one_delay(mock_env, simple_obs_func, device):
+  """Test lag=1 returns previous observation."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func, params={}, delay_min_lag=1, delay_max_lag=1
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  # Build sequence: 2, 3, 4, 5, 6
+  # Expected with lag=1: 2, 2, 3, 4, 5
+
+  obs1 = manager.compute(update_history=True)  # value=2, lag constrained, returns 2
+  assert isinstance(obs1["actor"], torch.Tensor)
+  assert torch.allclose(obs1["actor"][0], torch.full((3,), 2.0, device=device))
+
+  obs2 = manager.compute(update_history=True)  # value=3, lag=1, returns 2
+  assert isinstance(obs2["actor"], torch.Tensor)
+  assert torch.allclose(obs2["actor"][0], torch.full((3,), 2.0, device=device))
+
+  obs3 = manager.compute(update_history=True)  # value=4, lag=1, returns 3
+  assert isinstance(obs3["actor"], torch.Tensor)
+  assert torch.allclose(obs3["actor"][0], torch.full((3,), 3.0, device=device))
+
+  obs4 = manager.compute(update_history=True)  # value=5, lag=1, returns 4
+  assert isinstance(obs4["actor"], torch.Tensor)
+  assert torch.allclose(obs4["actor"][0], torch.full((3,), 4.0, device=device))
+
+  obs5 = manager.compute(update_history=True)  # value=6, lag=1, returns 5
+  assert isinstance(obs5["actor"], torch.Tensor)
+  assert torch.allclose(obs5["actor"][0], torch.full((3,), 5.0, device=device))
+
+
+##
+# Delay with other features.
+##
+
+
+def test_delay_with_history(mock_env, simple_obs_func, device):
+  """Test that delay is applied before history."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func,
+          params={},
+          delay_min_lag=1,
+          delay_max_lag=1,
+          history_length=2,
+          flatten_history_dim=False,
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  assert manager.group_obs_dim["actor"] == (2, 3)
+
+  # First compute: value=2, delay gives 2, history [2, 2].
+  obs1 = manager.compute(update_history=False)
+  policy_obs1 = obs1["actor"]
+  assert isinstance(policy_obs1, torch.Tensor)
+  assert torch.allclose(
+    policy_obs1[0],
+    torch.stack(
+      [torch.full((3,), 2.0, device=device), torch.full((3,), 2.0, device=device)]
+    ),
+  )
+
+  # Second compute: value=3, delay gives 2 (lag=1), history updated to [2, 2].
+  obs2 = manager.compute(update_history=True)
+  policy_obs2 = obs2["actor"]
+  assert isinstance(policy_obs2, torch.Tensor)
+  assert torch.allclose(
+    policy_obs2[0],
+    torch.stack(
+      [torch.full((3,), 2.0, device=device), torch.full((3,), 2.0, device=device)]
+    ),
+  )
+
+  # Third compute: value=4, delay gives 3 (lag=1), history updated to [2, 3].
+  obs3 = manager.compute(update_history=True)
+  policy_obs3 = obs3["actor"]
+  assert isinstance(policy_obs3, torch.Tensor)
+  assert torch.allclose(
+    policy_obs3[0],
+    torch.stack(
+      [torch.full((3,), 2.0, device=device), torch.full((3,), 3.0, device=device)]
+    ),
+  )
+
+
+def test_delay_with_scale(mock_env, simple_obs_func, device):
+  """Test that scaling is applied before delay."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func,
+          params={},
+          scale=2.0,
+          delay_min_lag=1,
+          delay_max_lag=1,
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  # First compute: value=2, scaled to 4.
+  obs1 = manager.compute(update_history=True)
+  assert isinstance(obs1["actor"], torch.Tensor)
+  assert torch.allclose(obs1["actor"][0], torch.full((3,), 4.0, device=device))
+
+  # Second compute: value=3, scaled to 6, delay returns 4 (lag=1).
+  obs2 = manager.compute(update_history=True)
+  assert isinstance(obs2["actor"], torch.Tensor)
+  assert torch.allclose(obs2["actor"][0], torch.full((3,), 4.0, device=device))
+
+  # Third compute: value=4, scaled to 8, delay returns 6 (lag=1).
+  obs3 = manager.compute(update_history=True)
+  assert isinstance(obs3["actor"], torch.Tensor)
+  assert torch.allclose(obs3["actor"][0], torch.full((3,), 6.0, device=device))
+
+
+##
+# Reset tests.
+##
+
+
+def test_reset_clears_delay_buffer(mock_env, simple_obs_func, device):
+  """Test that reset clears delay buffer and restarts lag constraint."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func, params={}, delay_min_lag=2, delay_max_lag=2
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  # Build up delay buffer with several steps.
+  obs = manager.compute(update_history=True)
+  for _ in range(4):
+    obs = manager.compute(update_history=True)
+  # At this point, delay should be working (lag=2).
+  # Value should be from 2 steps ago.
+  assert isinstance(obs["actor"], torch.Tensor)
+  last_val = obs["actor"][0, 0].item()
+
+  # Reset all environments.
+  manager.reset()
+
+  # After reset, buffer and lags are cleared.
+  # Next compute should return current (lag constrained to 0).
+  obs = manager.compute(update_history=True)
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  # Value should be current, not delayed.
+  current_val = policy_obs[0, 0].item()
+  # Verify it's different from before reset (counter continues).
+  assert current_val != last_val
+
+
+def test_reset_partial_envs_with_verification(mock_env, device):
+  """Test partial reset actually resets only specified environments."""
+  # Use per-env counters to track each env independently.
+  counters = torch.zeros(4, dtype=torch.long, device=device)
+
+  def per_env_obs_func(env):
+    counters[:] += 1
+    # Return different values per env so we can track them.
+    return counters.unsqueeze(1).repeat(1, 3).float()
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=per_env_obs_func, params={}, delay_min_lag=1, delay_max_lag=1
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  # Build up some history.
+  for _ in range(3):
+    manager.compute(update_history=True)
+
+  # Get obs for env 1 and 3 before reset.
+  obs_before = manager.compute(update_history=True)
+  assert isinstance(obs_before["actor"], torch.Tensor)
+  env1_before = obs_before["actor"][1, 0].item()
+  env3_before = obs_before["actor"][3, 0].item()
+
+  # Reset only envs 0 and 2.
+  manager.reset(env_ids=torch.tensor([0, 2], device=device))
+
+  # Next compute.
+  obs_after = manager.compute(update_history=True)
+
+  # Envs 1 and 3 should have continuous delayed values.
+  # Env 0 and 2 should have restarted (returning current due to lag constraint).
+  assert isinstance(obs_after["actor"], torch.Tensor)
+  env1_after = obs_after["actor"][1, 0].item()
+  env3_after = obs_after["actor"][3, 0].item()
+
+  # Non-reset envs should have changed (counter incremented).
+  assert env1_after != env1_before
+  assert env3_after != env3_before
+
+
+##
+# Shared vs per-env delay.
+##
+
+
+def test_shared_delay_actual_verification(mock_env, device):
+  """Verify that per_env=False gives same lag across all envs."""
+
+  # Use unique values per env to distinguish them.
+  def unique_obs_func(env):
+    # Return env index as the observation value.
+    return torch.arange(env.num_envs, device=device).unsqueeze(1).repeat(1, 3).float()
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=unique_obs_func,
+          params={},
+          delay_min_lag=0,
+          delay_max_lag=2,
+          delay_per_env=False,  # Same lag for all envs.
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  # Run several steps and track the delay buffer.
+  delay_buffer = manager._group_obs_term_delay_buffer["actor"]["obs1"]
+
+  for _ in range(10):
+    manager.compute(update_history=True)
+
+  # Check that all envs have the same lag.
+  lags = delay_buffer.current_lags
+  assert torch.all(lags == lags[0]), f"Expected same lag for all envs, got {lags}"
+
+
+##
+# Update period tests.
+##
+
+
+def test_update_period_actual_verification(mock_env, device):
+  """Verify that update_period controls lag update frequency."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=lambda env: torch.zeros((env.num_envs, 3), device=device),
+          params={},
+          delay_min_lag=0,
+          delay_max_lag=3,
+          delay_update_period=3,
+          delay_per_env_phase=False,  # All envs update together.
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  delay_buffer = manager._group_obs_term_delay_buffer["actor"]["obs1"]
+
+  # Track lag changes over time.
+  lag_history = []
+  for _ in range(12):
+    manager.compute(update_history=True)
+    lag_history.append(delay_buffer.current_lags[0].item())
+
+  # Lags should only change every 3 steps (at steps 0, 3, 6, 9).
+  assert len(lag_history) == 12
+
+
+##
+# Dimension verification tests.
+##
+
+
+def test_delay_preserves_dimensions(mock_env, simple_obs_func):
+  """Test that delay preserves observation dimensions."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func, params={}, delay_min_lag=1, delay_max_lag=3
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  assert manager.group_obs_dim["actor"] == (3,)
+
+  obs = manager.compute(update_history=True)
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  assert policy_obs.shape == (4, 3)
+
+
+def test_mixed_delay_and_no_delay_terms(mock_env, simple_obs_func, device):
+  """Test group with both delayed and non-delayed terms."""
+
+  counter = {"value": 0}
+
+  def obs_func2(env):
+    counter["value"] += 1
+    return torch.full((env.num_envs, 2), float(counter["value"]) * 10, device=device)
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs_with_delay": ObservationTermCfg(
+          func=simple_obs_func, params={}, delay_min_lag=1, delay_max_lag=1
+        ),
+        "obs_no_delay": ObservationTermCfg(func=obs_func2, params={}),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  # Should concatenate: 3 + 2 = 5.
+  assert manager.group_obs_dim["actor"] == (5,)
+
+  # First compute.
+  obs1 = manager.compute(update_history=True)
+  assert isinstance(obs1["actor"], torch.Tensor)
+  assert obs1["actor"].shape == (4, 5)
+  # First 3 values should be delayed obs (value 2).
+  # Last 2 values should be non-delayed obs (value 2*10=20).
+  assert torch.allclose(obs1["actor"][0, :3], torch.full((3,), 2.0, device=device))
+  assert torch.allclose(obs1["actor"][0, 3:], torch.full((2,), 20.0, device=device))
+
+  # Second compute.
+  obs2 = manager.compute(update_history=True)
+  assert isinstance(obs2["actor"], torch.Tensor)
+  # Delayed obs should be 2 (lag=1), non-delayed should be 3*10=30.
+  assert torch.allclose(obs2["actor"][0, :3], torch.full((3,), 2.0, device=device))
+  assert torch.allclose(obs2["actor"][0, 3:], torch.full((2,), 30.0, device=device))
+
+  # Third compute.
+  obs3 = manager.compute(update_history=True)
+  assert isinstance(obs3["actor"], torch.Tensor)
+  # Delayed obs should be 3 (lag=1), non-delayed should be 4*10=40.
+  assert torch.allclose(obs3["actor"][0, :3], torch.full((3,), 3.0, device=device))
+  assert torch.allclose(obs3["actor"][0, 3:], torch.full((2,), 40.0, device=device))
+
+
+##
+# Cache behavior tests.
+##
+
+
+def test_compute_without_update_returns_cached(mock_env, simple_obs_func):
+  """Test that compute(update_history=False) returns cached result.
+
+  This test verifies the fix for the double-push bug where calling compute()
+  multiple times per control step would push observations twice to the delay
+  buffer, effectively halving the actual delay.
+  """
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func, params={}, delay_min_lag=1, delay_max_lag=1
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  # First compute with update_history=True should compute fresh and push to buffer.
+  obs1 = manager.compute(update_history=True)
+  assert isinstance(obs1["actor"], torch.Tensor)
+  val1 = obs1["actor"][0, 0].item()
+
+  # Second compute with update_history=False should return cached result.
+  obs2 = manager.compute(update_history=False)
+  assert isinstance(obs2["actor"], torch.Tensor)
+  val2 = obs2["actor"][0, 0].item()
+  assert val1 == val2, "compute(update_history=False) should return cached result"
+
+  # Multiple calls without update should all return the same cached value.
+  for _ in range(5):
+    obs = manager.compute(update_history=False)
+    assert isinstance(obs["actor"], torch.Tensor)
+    assert obs["actor"][0, 0].item() == val1
+
+  # Third compute with update_history=True should compute fresh observations.
+  obs3 = manager.compute(update_history=True)
+  assert isinstance(obs3["actor"], torch.Tensor)
+  val3 = obs3["actor"][0, 0].item()
+  # Value should have advanced (previous value due to lag=1).
+  assert val3 == val1  # lag=1 returns previous observation
+
+
+def test_delay_buffer_not_double_pushed(mock_env, simple_obs_func):
+  """Test that delay buffer is not pushed twice per control step.
+
+  This tests the specific bug where calling compute() twice per control step
+  (e.g., in step() and get_observations()) would push observations twice,
+  effectively halving the actual delay.
+  """
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func, params={}, delay_min_lag=2, delay_max_lag=2
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  delay_buffer = manager._group_obs_term_delay_buffer["actor"]["obs1"]
+
+  # Simulate the training loop pattern:
+  # 1. compute(update_history=True) in step()
+  # 2. compute(update_history=False) in get_observations()
+
+  # First "step": compute with update, buffer should have 1 entry.
+  manager.compute(update_history=True)
+  assert delay_buffer._buffer.current_length[0].item() == 1
+
+  # Call compute without update (like get_observations does).
+  manager.compute(update_history=False)
+  # Buffer should STILL have 1 entry (not 2).
+  assert delay_buffer._buffer.current_length[0].item() == 1
+
+  # Second "step": compute with update, buffer should have 2 entries.
+  manager.compute(update_history=True)
+  assert delay_buffer._buffer.current_length[0].item() == 2
+
+  # Call compute without update multiple times.
+  for _ in range(3):
+    manager.compute(update_history=False)
+  # Buffer should STILL have 2 entries.
+  assert delay_buffer._buffer.current_length[0].item() == 2
+
+  # Third "step": compute with update, buffer should have 3 entries (max for lag=2).
+  manager.compute(update_history=True)
+  assert delay_buffer._buffer.current_length[0].item() == 3
+
+
+def test_cache_invalidated_on_reset(mock_env, simple_obs_func):
+  """Test that observation cache is invalidated when environments are reset."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func, params={}, delay_min_lag=1, delay_max_lag=1
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  # Build up some state.
+  for _ in range(3):
+    manager.compute(update_history=True)
+
+  # Get cached observation.
+  obs_before = manager.compute(update_history=False)
+  assert isinstance(obs_before["actor"], torch.Tensor)
+  val_before = obs_before["actor"][0, 0].item()
+
+  # Reset.
+  manager.reset()
+
+  # Next compute should return fresh observations (cache invalidated).
+  obs_after = manager.compute(update_history=True)
+  assert isinstance(obs_after["actor"], torch.Tensor)
+  val_after = obs_after["actor"][0, 0].item()
+
+  # After reset, delay buffer is cleared, so we get the current (fresh) observation.
+  # The value should have advanced since the obs_func counter continues incrementing.
+  assert val_after != val_before
diff --git a/tests/test_observation_history.py b/tests/test_observation_history.py
new file mode 100644
index 0000000..e38e7f8
--- /dev/null
+++ b/tests/test_observation_history.py
@@ -0,0 +1,612 @@
+"""Tests for observation history functionality."""
+
+from unittest.mock import Mock
+
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.managers.observation_manager import (
+  ObservationGroupCfg,
+  ObservationManager,
+  ObservationTermCfg,
+)
+
+
+@pytest.fixture
+def device():
+  """Test device fixture."""
+  return get_test_device()
+
+
+@pytest.fixture
+def mock_env(device):
+  """Create a mock environment."""
+  env = Mock()
+  env.num_envs = 4
+  env.device = device
+  env.step_dt = 0.02
+  return env
+
+
+@pytest.fixture
+def simple_obs_func(device):
+  """Create a simple observation function that returns a counter."""
+  counter = {"value": 0}
+
+  def obs_func(env):
+    counter["value"] += 1
+    return torch.full((env.num_envs, 3), float(counter["value"]), device=device)
+
+  return obs_func
+
+
+# Basic observation history tests.
+
+
+def test_no_history_by_default(mock_env, simple_obs_func):
+  """Test that observations work without history (default behavior)."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(func=simple_obs_func, params={}),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  assert manager.group_obs_dim["actor"] == (3,)
+
+  obs = manager.compute()
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  assert policy_obs.shape == (4, 3)
+
+
+def test_single_step_history(mock_env, simple_obs_func):
+  """Test observation with history_length=1."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(func=simple_obs_func, params={}, history_length=1),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  assert manager.group_obs_dim["actor"] == (3,)
+
+  obs = manager.compute()
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  assert policy_obs.shape == (4, 3)
+
+
+def test_multi_step_history_flattened(mock_env, simple_obs_func):
+  """Test observation with history_length=3 and flattened."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func, params={}, history_length=3, flatten_history_dim=True
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  assert manager.group_obs_dim["actor"] == (9,)
+
+  obs = manager.compute()
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  assert policy_obs.shape == (4, 9)
+
+
+def test_multi_step_history_not_flattened(mock_env, simple_obs_func):
+  """Test observation with history_length=3 and not flattened."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func, params={}, history_length=3, flatten_history_dim=False
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  assert manager.group_obs_dim["actor"] == (3, 3)
+
+  obs = manager.compute()
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  assert policy_obs.shape == (4, 3, 3)
+
+
+# History accumulation tests.
+
+
+def test_history_accumulates_correctly(mock_env, simple_obs_func):
+  """Test that history buffer accumulates observations in correct order."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func, params={}, history_length=3, flatten_history_dim=False
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  device = mock_env.device
+  # Note: counter is incremented during _prepare_terms (value=1).
+
+  # First compute uses value=2 and initializes buffer.
+  obs = manager.compute(update_history=False)
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  assert torch.allclose(policy_obs[0], torch.full((3, 3), 2.0, device=device))
+
+  # Update with value=3.
+  obs = manager.compute(update_history=True)
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  # History: [2, 2, 3] (oldest to newest).
+  expected = torch.stack(
+    [
+      torch.full((3,), 2.0, device=device),
+      torch.full((3,), 2.0, device=device),
+      torch.full((3,), 3.0, device=device),
+    ]
+  )
+  assert torch.allclose(policy_obs[0], expected)
+
+  # Update with value=4.
+  obs = manager.compute(update_history=True)
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  # History: [2, 3, 4].
+  expected = torch.stack(
+    [
+      torch.full((3,), 2.0, device=device),
+      torch.full((3,), 3.0, device=device),
+      torch.full((3,), 4.0, device=device),
+    ]
+  )
+  assert torch.allclose(policy_obs[0], expected)
+
+  # Update with value=5, circular overwrite.
+  obs = manager.compute(update_history=True)
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  # History: [3, 4, 5].
+  expected = torch.stack(
+    [
+      torch.full((3,), 3.0, device=device),
+      torch.full((3,), 4.0, device=device),
+      torch.full((3,), 5.0, device=device),
+    ]
+  )
+  assert torch.allclose(policy_obs[0], expected)
+
+
+def test_update_history_false_doesnt_modify_buffer(mock_env, simple_obs_func):
+  """Test that update_history=False doesn't modify the buffer."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func, params={}, history_length=2, flatten_history_dim=False
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  # Initialize (value=1).
+  obs1 = manager.compute(update_history=False)
+  policy_obs1 = obs1["actor"]
+  assert isinstance(policy_obs1, torch.Tensor)
+
+  # Call without update (value=2, but buffer unchanged).
+  obs2 = manager.compute(update_history=False)
+  policy_obs2 = obs2["actor"]
+  assert isinstance(policy_obs2, torch.Tensor)
+
+  # History should still be [1, 1].
+  assert torch.allclose(policy_obs1, policy_obs2)
+
+
+# Group-level history override tests.
+
+
+def test_group_history_overrides_term(mock_env, simple_obs_func):
+  """Test group history_length overrides term history_length."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      history_length=5,  # Group level.
+      flatten_history_dim=False,
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func,
+          params={},
+          history_length=2,  # Overridden.
+        ),
+      },
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  assert manager.group_obs_dim["actor"] == (5, 3)
+
+  obs = manager.compute()
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  assert policy_obs.shape == (4, 5, 3)
+
+
+# History reset tests.
+
+
+def test_reset_clears_all_envs(mock_env, simple_obs_func):
+  """Test that reset without env_ids clears all environments."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func, params={}, history_length=2, flatten_history_dim=False
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  # Build up history.
+  manager.compute(update_history=True)
+  manager.compute(update_history=True)
+
+  # Reset all.
+  manager.reset()
+
+  # Buffer should be zeroed.
+  obs = manager.compute(update_history=False)
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  assert torch.allclose(policy_obs, torch.zeros((4, 2, 3), device=mock_env.device))
+
+
+def test_reset_partial_envs(mock_env, simple_obs_func):
+  """Test that reset with specific env_ids only resets those envs."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func, params={}, history_length=3, flatten_history_dim=False
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  # Build up history.
+  manager.compute(update_history=True)
+  manager.compute(update_history=True)
+  obs_before = manager.compute(update_history=True)
+  policy_obs_before = obs_before["actor"]
+  assert isinstance(policy_obs_before, torch.Tensor)
+
+  # Reset only envs 0 and 2.
+  manager.reset(env_ids=torch.tensor([0, 2], device=mock_env.device))
+
+  obs_after = manager.compute(update_history=False)
+  policy_obs_after = obs_after["actor"]
+  assert isinstance(policy_obs_after, torch.Tensor)
+
+  # Envs 0 and 2 should be reset (zeros), 1 and 3 unchanged.
+  assert torch.allclose(
+    policy_obs_after[0], torch.zeros((3, 3), device=mock_env.device)
+  )
+  assert torch.allclose(policy_obs_after[1], policy_obs_before[1])
+  assert torch.allclose(
+    policy_obs_after[2], torch.zeros((3, 3), device=mock_env.device)
+  )
+  assert torch.allclose(policy_obs_after[3], policy_obs_before[3])
+
+
+def test_reset_partial_envs_with_backfill(mock_env, simple_obs_func):
+  """Test that reset envs get backfilled on next update."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func, params={}, history_length=3, flatten_history_dim=False
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  device = mock_env.device
+
+  # Build history: [2, 3, 4] for all envs (counter starts at 1 after _prepare_terms).
+  manager.compute(update_history=True)  # value=2
+  manager.compute(update_history=True)  # value=3
+  manager.compute(update_history=True)  # value=4
+
+  # Reset only envs 0 and 2.
+  manager.reset(env_ids=torch.tensor([0, 2], device=device))
+
+  # Next update with value=5.
+  obs = manager.compute(update_history=True)
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+
+  # Env 0: [5, 5, 5] (backfilled after reset).
+  expected_env0 = torch.stack(
+    [
+      torch.full((3,), 5.0, device=device),
+      torch.full((3,), 5.0, device=device),
+      torch.full((3,), 5.0, device=device),
+    ]
+  )
+  assert torch.allclose(policy_obs[0], expected_env0)
+
+  # Env 1: [3, 4, 5] (continues normally).
+  expected_env1 = torch.stack(
+    [
+      torch.full((3,), 3.0, device=device),
+      torch.full((3,), 4.0, device=device),
+      torch.full((3,), 5.0, device=device),
+    ]
+  )
+  assert torch.allclose(policy_obs[1], expected_env1)
+
+  # Env 2: [5, 5, 5] (backfilled after reset).
+  assert torch.allclose(policy_obs[2], expected_env0)
+
+  # Env 3: [3, 4, 5] (continues normally).
+  assert torch.allclose(policy_obs[3], expected_env1)
+
+
+# History with other features tests.
+
+
+def test_history_with_clip(mock_env, simple_obs_func):
+  """Test that clipping is applied before history."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func,
+          params={},
+          history_length=2,
+          flatten_history_dim=False,
+          clip=(-0.5, 0.5),
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  obs = manager.compute(update_history=True)
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  # Values should be clipped.
+  assert torch.all(policy_obs >= -0.5)
+  assert torch.all(policy_obs <= 0.5)
+
+
+def test_history_with_scale(mock_env, simple_obs_func):
+  """Test that scaling is applied before history."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func,
+          params={},
+          history_length=2,
+          flatten_history_dim=False,
+          scale=2.0,
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  device = mock_env.device
+  # Counter at 1 after _prepare_terms.
+
+  # First call uses value=2, scaled to 4, initializes buffer.
+  manager.compute(update_history=False)
+  # Second call uses value=3, scaled to 6, and updates history.
+  obs = manager.compute(update_history=True)
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+
+  # History: [4, 6].
+  expected = torch.stack(
+    [torch.full((3,), 4.0, device=device), torch.full((3,), 6.0, device=device)]
+  )
+  assert torch.allclose(policy_obs[0], expected)
+
+
+# Mixed history terms tests.
+
+
+def test_mixed_terms_concatenated(mock_env, simple_obs_func, device):
+  """Test group with both history and non-history terms concatenated."""
+
+  counter = {"value": 0}
+
+  def obs_func2(env):
+    counter["value"] += 1
+    return torch.full((env.num_envs, 2), float(counter["value"]) * 10, device=device)
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs_with_history": ObservationTermCfg(
+          func=simple_obs_func, params={}, history_length=2, flatten_history_dim=True
+        ),
+        "obs_no_history": ObservationTermCfg(func=obs_func2, params={}),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  # Should concatenate: (3*2) + 2 = 8.
+  assert manager.group_obs_dim["actor"] == (8,)
+
+  obs = manager.compute()
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  assert policy_obs.shape == (4, 8)
+
+
+def test_no_double_append_on_first_call(mock_env, simple_obs_func):
+  """Test that first call with update_history=True only appends once, not twice."""
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=simple_obs_func, params={}, history_length=3, flatten_history_dim=False
+        ),
+      }
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  device = mock_env.device
+  # Counter is at 1 after _prepare_terms.
+
+  # First call with update_history=True (value=2).
+  # This should initialize the buffer AND append once (not twice).
+  obs = manager.compute(update_history=True)
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+
+  # Verify buffer was initialized and backfilled correctly.
+  # All slots should be filled with value 2.
+  expected_first = torch.stack(
+    [
+      torch.full((3,), 2.0, device=device),
+      torch.full((3,), 2.0, device=device),
+      torch.full((3,), 2.0, device=device),
+    ]
+  )
+  assert torch.allclose(policy_obs[0], expected_first)
+
+  # Get the circular buffer and check pointer position.
+  circular_buffer = manager._group_obs_term_history_buffer["actor"]["obs1"]
+  # After one append, pointer should be at 0 (not 1 which would indicate double-append).
+  assert circular_buffer._pointer == 0
+  # And we should have exactly 1 push recorded.
+  assert torch.all(circular_buffer._num_pushes == 1)
+
+  # Second call with update_history=True (value=3).
+  obs = manager.compute(update_history=True)
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+
+  # History should be [2, 2, 3] (oldest to newest).
+  expected_second = torch.stack(
+    [
+      torch.full((3,), 2.0, device=device),
+      torch.full((3,), 2.0, device=device),
+      torch.full((3,), 3.0, device=device),
+    ]
+  )
+  assert torch.allclose(policy_obs[0], expected_second)
+
+  # Pointer should now be at 1.
+  assert circular_buffer._pointer == 1
+  # And we should have exactly 2 pushes.
+  assert torch.all(circular_buffer._num_pushes == 2)
+
+
+def test_term_major_ordering(mock_env, device):
+  """Test that history flattening uses term-major ordering.
+
+  Term-major: [A_t0, A_t1, ..., A_tH-1, B_t0, B_t1, ..., B_tH-1]
+  Time-major: [A_t0, B_t0, ..., A_t1, B_t1, ..., A_tH-1, B_tH-1]
+
+  This test verifies mjlab uses term-major ordering.
+  """
+
+  # Create observation functions with distinct values per term.
+  def obs_A(env):
+    # Returns [100, 101] for easy identification.
+    return torch.tensor([[100.0, 101.0]] * env.num_envs, device=device)
+
+  def obs_B(env):
+    # Returns [200, 201, 202] for easy identification.
+    return torch.tensor([[200.0, 201.0, 202.0]] * env.num_envs, device=device)
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      concatenate_terms=True,
+      terms={
+        "term_A": ObservationTermCfg(
+          func=obs_A, params={}, history_length=3, flatten_history_dim=True
+        ),
+        "term_B": ObservationTermCfg(
+          func=obs_B, params={}, history_length=3, flatten_history_dim=True
+        ),
+      },
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  # Compute observations (history will be backfilled with same values).
+  obs = manager.compute(update_history=False)
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+
+  # Expected shape: (4 envs, 2*3 + 3*3) = (4, 15).
+  assert policy_obs.shape == (4, 15)
+
+  # Check ordering for first environment.
+  result = policy_obs[0].cpu().tolist()
+
+  # Term-major: all A history, then all B history.
+  # A has 2 dims, B has 3 dims, history_length=3.
+  # fmt: off
+  expected_term_major = [
+    100.0, 101.0, 100.0, 101.0, 100.0, 101.0,  # All A history
+    200.0, 201.0, 202.0, 200.0, 201.0, 202.0, 200.0, 201.0, 202.0,  # All B
+  ]
+  # fmt: on
+
+  # Time-major would interleave: [A_t0, B_t0, A_t1, B_t1, A_t2, B_t2].
+  # fmt: off
+  expected_time_major = [
+    100.0, 101.0, 200.0, 201.0, 202.0,  # Frame t0
+    100.0, 101.0, 200.0, 201.0, 202.0,  # Frame t1
+    100.0, 101.0, 200.0, 201.0, 202.0,  # Frame t2
+  ]
+  # fmt: on
+
+  # Verify term-major ordering.
+  assert result == expected_term_major, f"Expected term-major ordering, got {result}"
+  assert result != expected_time_major, "Should not match time-major"
diff --git a/tests/test_observation_manager.py b/tests/test_observation_manager.py
new file mode 100644
index 0000000..73baf6e
--- /dev/null
+++ b/tests/test_observation_manager.py
@@ -0,0 +1,63 @@
+"""Tests for ObservationManager behavior."""
+
+from unittest.mock import Mock
+
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.managers.observation_manager import (
+  ObservationGroupCfg,
+  ObservationManager,
+  ObservationTermCfg,
+)
+
+
+@pytest.fixture
+def mock_env():
+  env = Mock()
+  env.num_envs = 4
+  env.device = get_test_device()
+  env.step_dt = 0.02
+  return env
+
+
+def _dummy_term(mock_env):
+  def func(_env, **_kwargs):
+    return torch.zeros(mock_env.num_envs, 3, device=mock_env.device)
+
+  return ObservationTermCfg(func=func)
+
+
+def test_empty_terms_dict_skipped(mock_env):
+  """A group declared with no terms is skipped rather than raising."""
+  cfg = {"actor": ObservationGroupCfg(terms={})}
+  mgr = ObservationManager(cfg, mock_env)
+
+  assert "actor" not in mgr.active_terms
+  assert "actor" not in mgr.group_obs_dim
+
+
+def test_all_terms_none_skipped(mock_env):
+  """A group whose every term is None is skipped rather than raising."""
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={"a": None, "b": None},  # type: ignore[dict-item]
+    ),
+  }
+  mgr = ObservationManager(cfg, mock_env)
+
+  assert "actor" not in mgr.active_terms
+  assert "actor" not in mgr.group_obs_dim
+
+
+def test_empty_group_skipped_alongside_active_group(mock_env):
+  """Active groups coexist with empty ones; only the empty group is dropped."""
+  cfg = {
+    "actor": ObservationGroupCfg(terms={"a": _dummy_term(mock_env)}),
+    "critic": ObservationGroupCfg(terms={}),
+  }
+  mgr = ObservationManager(cfg, mock_env)
+
+  assert "actor" in mgr.active_terms
+  assert "critic" not in mgr.active_terms
diff --git a/tests/test_observation_nan_handling.py b/tests/test_observation_nan_handling.py
new file mode 100644
index 0000000..f37179a
--- /dev/null
+++ b/tests/test_observation_nan_handling.py
@@ -0,0 +1,428 @@
+"""Tests for observation NaN handling functionality."""
+
+from unittest.mock import Mock
+
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.managers.observation_manager import (
+  ObservationGroupCfg,
+  ObservationManager,
+  ObservationTermCfg,
+)
+
+
+@pytest.fixture
+def device():
+  """Test device fixture."""
+  return get_test_device()
+
+
+@pytest.fixture
+def mock_env(device):
+  """Create a mock environment."""
+  env = Mock()
+  env.num_envs = 4
+  env.device = device
+  env.step_dt = 0.02
+  return env
+
+
+def test_nan_disabled_policy_no_check(mock_env, device):
+  """Policy='disabled' should pass through NaNs unchanged."""
+
+  def obs_with_nan(env):
+    obs = torch.ones((env.num_envs, 3), device=device)
+    obs[1, 1] = float("nan")
+    return obs
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={"obs1": ObservationTermCfg(func=obs_with_nan, params={})},
+      nan_policy="disabled",
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  obs = manager.compute()
+
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  assert torch.isnan(policy_obs[1, 1])  # NaN should pass through.
+
+
+def test_nan_sanitize_policy_silently_fixes(mock_env, device):
+  """Policy='sanitize' should zero NaNs without warning."""
+
+  def obs_with_nan(env):
+    obs = torch.ones((env.num_envs, 3), device=device)
+    obs[1, 1] = float("nan")
+    obs[2, 0] = float("inf")
+    return obs
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={"obs1": ObservationTermCfg(func=obs_with_nan, params={})},
+      nan_policy="sanitize",
+      nan_check_per_term=True,
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  obs = manager.compute()
+
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  assert not torch.isnan(policy_obs).any()
+  assert not torch.isinf(policy_obs).any()
+  assert policy_obs[1, 1] == 0.0
+  assert policy_obs[2, 0] == 0.0
+
+
+def test_nan_warn_policy_logs_and_sanitizes(mock_env, device, capsys):
+  """Policy='warn' should log warning and sanitize."""
+
+  def obs_with_nan(env):
+    obs = torch.ones((env.num_envs, 3), device=device)
+    obs[1, 1] = float("nan")
+    return obs
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={"obs1": ObservationTermCfg(func=obs_with_nan, params={})},
+      nan_policy="warn",
+      nan_check_per_term=True,
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  obs = manager.compute()
+
+  captured = capsys.readouterr()
+  assert "ObservationManager" in captured.out
+  assert "NaN/Inf" in captured.out
+  assert "actor/obs1" in captured.out
+  assert "Sanitizing" in captured.out
+
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  assert not torch.isnan(policy_obs).any()
+  assert policy_obs[1, 1] == 0.0
+
+
+def test_nan_error_policy_raises(mock_env, device):
+  """Policy='error' should raise ValueError with context."""
+
+  def obs_with_nan(env):
+    obs = torch.ones((env.num_envs, 3), device=device)
+    obs[1, 1] = float("nan")
+    return obs
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={"obs1": ObservationTermCfg(func=obs_with_nan, params={})},
+      nan_policy="error",
+      nan_check_per_term=True,
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  with pytest.raises(ValueError) as excinfo:
+    manager.compute()
+
+  assert "NaN/Inf detected" in str(excinfo.value)
+  assert "actor/obs1" in str(excinfo.value)
+  assert "1" in str(excinfo.value)  # Environment ID.
+
+
+def test_nan_check_per_term_identifies_source(mock_env, device, capsys):
+  """Per-term checking should identify which term has NaN."""
+
+  def clean_obs(env):
+    return torch.ones((env.num_envs, 3), device=device)
+
+  def obs_with_nan(env):
+    obs = torch.ones((env.num_envs, 3), device=device)
+    obs[1, 1] = float("nan")
+    return obs
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "clean": ObservationTermCfg(func=clean_obs, params={}),
+        "problematic": ObservationTermCfg(func=obs_with_nan, params={}),
+      },
+      nan_policy="warn",
+      nan_check_per_term=True,
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  obs = manager.compute()
+
+  # Check that only problematic term is logged.
+  captured = capsys.readouterr()
+  assert "actor/problematic" in captured.out
+  assert "actor/clean" not in captured.out
+
+  # Both terms should be sanitized in output.
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  assert not torch.isnan(policy_obs).any()
+
+
+def test_nan_check_final_only(mock_env, device, capsys):
+  """Final-only checking should check concatenated result."""
+
+  def obs_with_nan(env):
+    obs = torch.ones((env.num_envs, 3), device=device)
+    obs[1, 1] = float("nan")
+    return obs
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={"obs1": ObservationTermCfg(func=obs_with_nan, params={})},
+      nan_policy="warn",
+      nan_check_per_term=False,  # Check only final result.
+      concatenate_terms=True,
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  obs = manager.compute()
+
+  # Should log group name, not term name.
+  captured = capsys.readouterr()
+  assert "actor" in captured.out
+  assert "actor/obs1" not in captured.out  # Should not show term.
+
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  assert not torch.isnan(policy_obs).any()
+
+
+def test_nan_check_dict_output(mock_env, device):
+  """NaN checking should work with non-concatenated dict output."""
+
+  def obs_with_nan(env):
+    obs = torch.ones((env.num_envs, 3), device=device)
+    obs[1, 1] = float("nan")
+    return obs
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={"obs1": ObservationTermCfg(func=obs_with_nan, params={})},
+      nan_policy="sanitize",
+      concatenate_terms=False,
+      nan_check_per_term=False,
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  obs = manager.compute()
+
+  policy: dict[str, torch.Tensor] = obs["actor"]  # type: ignore[assignment]
+  policy_obs = policy["obs1"]
+  assert not torch.isnan(policy_obs).any()
+  assert policy_obs[1, 1] == 0.0
+
+
+def test_nan_before_delay_buffer(mock_env, device):
+  """NaN should be sanitized before entering delay buffer."""
+
+  call_count = [0]
+
+  def obs_with_nan(env):
+    obs = torch.ones((env.num_envs, 3), device=device)
+    # Only inject NaN on first call.
+    if call_count[0] == 0:
+      obs[1, 1] = float("nan")
+    call_count[0] += 1
+    return obs
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=obs_with_nan,
+          params={},
+          delay_min_lag=1,
+          delay_max_lag=1,  # 1-step delay.
+        )
+      },
+      nan_policy="sanitize",
+      nan_check_per_term=True,
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  # First compute: NaN should be sanitized before entering delay buffer.
+  obs1 = manager.compute(update_history=True)
+  # First output comes from buffer initialization (zeros).
+  obs1_policy = obs1["actor"]
+  assert isinstance(obs1_policy, torch.Tensor)
+  assert not torch.isnan(obs1_policy).any()
+
+  # Second compute: should get sanitized value from buffer.
+  obs2 = manager.compute(update_history=True)
+  obs2_policy = obs2["actor"]
+  assert isinstance(obs2_policy, torch.Tensor)
+  assert not torch.isnan(obs2_policy).any()
+
+
+def test_nan_before_history_buffer(mock_env, device):
+  """NaN should be sanitized before entering history buffer."""
+
+  call_count = [0]
+
+  def obs_with_nan(env):
+    obs = torch.ones((env.num_envs, 3), device=device)
+    # Inject NaN on first call.
+    if call_count[0] == 0:
+      obs[1, 1] = float("nan")
+    call_count[0] += 1
+    return obs
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=obs_with_nan, params={}, history_length=3, flatten_history_dim=True
+        )
+      },
+      nan_policy="sanitize",
+      nan_check_per_term=True,
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+
+  # First compute: NaN should be sanitized.
+  obs1 = manager.compute(update_history=True)
+  obs1_policy = obs1["actor"]
+  assert isinstance(obs1_policy, torch.Tensor)
+  assert not torch.isnan(obs1_policy).any()
+
+  # Subsequent computes should also have no NaN from history.
+  for _ in range(3):
+    obs = manager.compute(update_history=True)
+    obs_policy = obs["actor"]
+    assert isinstance(obs_policy, torch.Tensor)
+    assert not torch.isnan(obs_policy).any()
+
+
+def test_nan_handling_with_multiple_groups(mock_env, device):
+  """NaN handling should work independently for multiple groups."""
+
+  def obs_with_nan(env):
+    obs = torch.ones((env.num_envs, 3), device=device)
+    obs[1, 1] = float("nan")
+    return obs
+
+  def clean_obs(env):
+    return torch.ones((env.num_envs, 3), device=device)
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={"obs1": ObservationTermCfg(func=obs_with_nan, params={})},
+      nan_policy="sanitize",
+    ),
+    "critic": ObservationGroupCfg(
+      terms={"obs1": ObservationTermCfg(func=clean_obs, params={})},
+      nan_policy="disabled",
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  obs = manager.compute()
+
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  assert not torch.isnan(policy_obs).any()
+
+  critic_obs = obs["critic"]
+  assert isinstance(critic_obs, torch.Tensor)
+  assert not torch.isnan(critic_obs).any()
+
+
+def test_nan_handling_with_scaling(mock_env, device):
+  """NaN handling should work correctly with scaling applied."""
+
+  def obs_with_nan(env):
+    obs = torch.full((env.num_envs, 3), 2.0, device=device)
+    obs[1, 1] = float("nan")
+    return obs
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={"obs1": ObservationTermCfg(func=obs_with_nan, params={}, scale=0.5)},
+      nan_policy="sanitize",
+      nan_check_per_term=True,
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  obs = manager.compute()
+
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  # NaN should be sanitized to 0, other values scaled: 2.0 * 0.5 = 1.0.
+  assert not torch.isnan(policy_obs).any()
+  assert policy_obs[1, 1] == 0.0
+  assert policy_obs[0, 0] == 1.0  # Scaled value.
+
+
+def test_nan_handling_with_clipping(mock_env, device):
+  """NaN handling should work correctly with clipping applied."""
+
+  def obs_with_nan(env):
+    obs = torch.full((env.num_envs, 3), 10.0, device=device)
+    obs[1, 1] = float("nan")
+    return obs
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(func=obs_with_nan, params={}, clip=(-1.0, 1.0))
+      },
+      nan_policy="sanitize",
+      nan_check_per_term=True,
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  obs = manager.compute()
+
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  # NaN should be sanitized to 0, other values clipped to 1.0.
+  assert not torch.isnan(policy_obs).any()
+  assert policy_obs[1, 1] == 0.0
+  assert policy_obs[0, 0] == 1.0  # Clipped value.
+
+
+def test_negative_inf_handling(mock_env, device):
+  """Test that negative infinity is also handled."""
+
+  def obs_with_neginf(env):
+    obs = torch.ones((env.num_envs, 3), device=device)
+    obs[1, 1] = float("-inf")
+    return obs
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={"obs1": ObservationTermCfg(func=obs_with_neginf, params={})},
+      nan_policy="sanitize",
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  obs = manager.compute()
+
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  assert not torch.isinf(policy_obs).any()
+  assert policy_obs[1, 1] == 0.0
diff --git a/tests/test_observation_noise.py b/tests/test_observation_noise.py
new file mode 100644
index 0000000..d6d55d8
--- /dev/null
+++ b/tests/test_observation_noise.py
@@ -0,0 +1,315 @@
+"""Tests for observation noise functionality."""
+
+from unittest.mock import Mock
+
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.managers.observation_manager import (
+  ObservationGroupCfg,
+  ObservationManager,
+  ObservationTermCfg,
+)
+from mjlab.utils.noise.noise_cfg import (
+  ConstantNoiseCfg,
+  NoiseModelWithAdditiveBiasCfg,
+)
+
+
+@pytest.fixture
+def device():
+  """Test device fixture."""
+  return get_test_device()
+
+
+@pytest.fixture
+def mock_env(device):
+  """Create a mock environment."""
+  env = Mock()
+  env.num_envs = 4
+  env.device = device
+  env.step_dt = 0.02
+  return env
+
+
+def test_noise_applied_when_corruption_enabled(mock_env, device):
+  """Test that noise is applied when enable_corruption=True."""
+
+  def obs_func(env):
+    return torch.ones((env.num_envs, 3), device=device)
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=obs_func,
+          params={},
+          noise=ConstantNoiseCfg(bias=0.5, operation="add"),
+        ),
+      },
+      enable_corruption=True,
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  obs = manager.compute()
+
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  # Expect 1.0 + 0.5 = 1.5
+  expected = torch.full((4, 3), 1.5, device=device)
+  assert torch.allclose(policy_obs, expected)
+
+
+def test_noise_not_applied_when_corruption_disabled(mock_env, device):
+  """Test that noise is NOT applied when enable_corruption=False."""
+
+  def obs_func(env):
+    return torch.ones((env.num_envs, 3), device=device)
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=obs_func,
+          params={},
+          noise=ConstantNoiseCfg(bias=0.5, operation="add"),
+        ),
+      },
+      enable_corruption=False,
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  obs = manager.compute()
+
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  # Noise should NOT be applied, expect original value of 1.0
+  expected = torch.full((4, 3), 1.0, device=device)
+  assert torch.allclose(policy_obs, expected)
+
+
+def test_noise_add_operation(mock_env, device):
+  """Test noise with 'add' operation."""
+
+  def obs_func(env):
+    return torch.full((env.num_envs, 3), 2.0, device=device)
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=obs_func,
+          params={},
+          noise=ConstantNoiseCfg(bias=0.3, operation="add"),
+        ),
+      },
+      enable_corruption=True,
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  obs = manager.compute()
+
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  # Expect 2.0 + 0.3 = 2.3
+  expected = torch.full((4, 3), 2.3, device=device)
+  assert torch.allclose(policy_obs, expected)
+
+
+def test_noise_scale_operation(mock_env, device):
+  """Test noise with 'scale' operation."""
+
+  def obs_func(env):
+    return torch.full((env.num_envs, 3), 2.0, device=device)
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=obs_func,
+          params={},
+          noise=ConstantNoiseCfg(bias=0.5, operation="scale"),
+        ),
+      },
+      enable_corruption=True,
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  obs = manager.compute()
+
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  # Expect 2.0 * 0.5 = 1.0
+  expected = torch.full((4, 3), 1.0, device=device)
+  assert torch.allclose(policy_obs, expected)
+
+
+def test_noise_abs_operation(mock_env, device):
+  """Test noise with 'abs' operation (replaces data with bias)."""
+
+  def obs_func(env):
+    return torch.full((env.num_envs, 3), 2.0, device=device)
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=obs_func,
+          params={},
+          noise=ConstantNoiseCfg(bias=0.7, operation="abs"),
+        ),
+      },
+      enable_corruption=True,
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  obs = manager.compute()
+
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  # Expect data to be replaced with bias = 0.7
+  expected = torch.full((4, 3), 0.7, device=device)
+  assert torch.allclose(policy_obs, expected)
+
+
+def test_noise_with_per_dimension_bias(mock_env, device):
+  """Test noise with per-dimension bias (tuple)."""
+
+  def obs_func(env):
+    return torch.ones((env.num_envs, 3), device=device)
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs1": ObservationTermCfg(
+          func=obs_func,
+          params={},
+          noise=ConstantNoiseCfg(bias=(0.1, 0.2, 0.3), operation="add"),
+        ),
+      },
+      enable_corruption=True,
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  obs = manager.compute()
+
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  # Expect 1.0 + [0.1, 0.2, 0.3] = [1.1, 1.2, 1.3]
+  expected = torch.tensor([[1.1, 1.2, 1.3]] * 4, device=device)
+  assert torch.allclose(policy_obs, expected)
+
+
+def test_noise_tensor_caching(device):
+  """Test that tensor conversion is cached across multiple calls."""
+  noise = ConstantNoiseCfg(bias=0.5)
+  data = torch.ones((4, 3), device=device)
+
+  # First call should create the tensor
+  result1 = noise.apply(data)
+
+  # Verify the cache was populated and get reference to cached tensor
+  device_key = str(result1.device)
+  assert device_key in noise._tensor_cache
+  assert "bias" in noise._tensor_cache[device_key]
+  cached_tensor = noise._tensor_cache[device_key]["bias"]
+  cached_data_ptr = cached_tensor.data_ptr()
+
+  # Second call should use the same cached tensor
+  result2 = noise.apply(data)
+
+  # Verify the cached tensor is the same object (same memory address)
+  assert noise._tensor_cache[device_key]["bias"].data_ptr() == cached_data_ptr
+
+  # Both results should be correct
+  expected = torch.full((4, 3), 1.5, device=device)
+  assert torch.allclose(result1, expected)
+  assert torch.allclose(result2, expected)
+
+
+def test_shared_term_name_noise_models_are_per_group(mock_env, device):
+  """Each group owns its own noise model instance when they share a term name.
+
+  ConstantNoiseCfg(op="add") shifts the additive-bias tensor by the configured
+  amount on every reset, so each group's observation drifts by its own value
+  after each manager.reset().
+  """
+
+  def obs_func(env):
+    return torch.zeros((env.num_envs, 3), device=device)
+
+  def group(bias: float) -> ObservationGroupCfg:
+    return ObservationGroupCfg(
+      terms={
+        "obs": ObservationTermCfg(
+          func=obs_func,
+          params={},
+          noise=NoiseModelWithAdditiveBiasCfg(
+            noise_cfg=ConstantNoiseCfg(bias=0.0, operation="add"),
+            bias_noise_cfg=ConstantNoiseCfg(bias=bias, operation="add"),
+          ),
+        ),
+      },
+      enable_corruption=True,
+    )
+
+  manager = ObservationManager({"actor": group(10.0), "critic": group(-1.0)}, mock_env)
+
+  obs = manager.compute()
+  assert isinstance(obs["actor"], torch.Tensor)
+  assert isinstance(obs["critic"], torch.Tensor)
+  assert torch.allclose(obs["actor"], torch.full((4, 3), 10.0, device=device))
+  assert torch.allclose(obs["critic"], torch.full((4, 3), -1.0, device=device))
+
+  manager.reset()
+  obs = manager.compute()
+  assert isinstance(obs["actor"], torch.Tensor)
+  assert isinstance(obs["critic"], torch.Tensor)
+  assert torch.allclose(obs["actor"], torch.full((4, 3), 20.0, device=device))
+  assert torch.allclose(obs["critic"], torch.full((4, 3), -2.0, device=device))
+
+
+def test_multiple_terms_with_different_noise(mock_env, device):
+  """Test multiple observation terms with different noise configs."""
+
+  def obs_func_a(env):
+    return torch.ones((env.num_envs, 2), device=device)
+
+  def obs_func_b(env):
+    return torch.full((env.num_envs, 2), 3.0, device=device)
+
+  cfg = {
+    "actor": ObservationGroupCfg(
+      terms={
+        "obs_a": ObservationTermCfg(
+          func=obs_func_a,
+          params={},
+          noise=ConstantNoiseCfg(bias=0.1, operation="add"),
+        ),
+        "obs_b": ObservationTermCfg(
+          func=obs_func_b,
+          params={},
+          noise=ConstantNoiseCfg(bias=2.0, operation="scale"),
+        ),
+      },
+      enable_corruption=True,
+    ),
+  }
+
+  manager = ObservationManager(cfg, mock_env)
+  obs = manager.compute()
+
+  policy_obs = obs["actor"]
+  assert isinstance(policy_obs, torch.Tensor)
+  # obs_a: 1.0 + 0.1 = 1.1
+  # obs_b: 3.0 * 2.0 = 6.0
+  # Concatenated: [1.1, 1.1, 6.0, 6.0]
+  expected = torch.tensor([[1.1, 1.1, 6.0, 6.0]] * 4, device=device)
+  assert torch.allclose(policy_obs, expected)
diff --git a/tests/test_offscreen_renderer.py b/tests/test_offscreen_renderer.py
new file mode 100644
index 0000000..c01e92a
--- /dev/null
+++ b/tests/test_offscreen_renderer.py
@@ -0,0 +1,45 @@
+"""Tests for offscreen renderer environment selection."""
+
+import numpy as np
+import pytest
+
+from mjlab.viewer.offscreen_renderer import OffscreenRenderer
+from mjlab.viewer.viewer_config import ViewerConfig
+
+
+def test_env_ids_clamps_when_fewer_envs_than_requested():
+  # Default max_extra_envs=2 with a single env must not raise (csv_to_npz and
+  # single-env video recording rely on this).
+  cfg = ViewerConfig(max_extra_envs=2)
+  ids = OffscreenRenderer._get_env_ids(cfg, np.zeros((1, 3)))
+  assert ids == (0,)
+
+
+def test_env_ids_primary_is_env_idx_despite_identical_origins():
+  # With identical origins, distance ties must not evict env_idx from the set.
+  cfg = ViewerConfig(env_idx=3, max_extra_envs=2)
+  ids = OffscreenRenderer._get_env_ids(cfg, np.zeros((8, 3)))
+  assert ids[0] == 3
+  assert len(ids) == 3
+  assert len(set(ids)) == 3
+
+
+def test_env_ids_selects_nearest_neighbors():
+  cfg = ViewerConfig(env_idx=0, max_extra_envs=2)
+  origins = np.array(
+    [[0.0, 0.0, 0.0], [10.0, 0.0, 0.0], [1.0, 0.0, 0.0], [2.0, 0.0, 0.0]]
+  )
+  ids = OffscreenRenderer._get_env_ids(cfg, origins)
+  assert ids == (0, 2, 3)
+
+
+def test_env_ids_out_of_range_env_idx_is_clamped():
+  cfg = ViewerConfig(env_idx=99, max_extra_envs=0)
+  ids = OffscreenRenderer._get_env_ids(cfg, np.zeros((4, 3)))
+  assert ids == (3,)
+
+
+def test_env_ids_negative_max_extra_envs_raises():
+  cfg = ViewerConfig(max_extra_envs=-1)
+  with pytest.raises(ValueError, match="max_extra_envs"):
+    OffscreenRenderer._get_env_ids(cfg, np.zeros((4, 3)))
diff --git a/tests/test_pd_actuator.py b/tests/test_pd_actuator.py
new file mode 100644
index 0000000..26f97a2
--- /dev/null
+++ b/tests/test_pd_actuator.py
@@ -0,0 +1,164 @@
+"""Tests for PD actuator equivalence."""
+
+import pytest
+import torch
+from conftest import (
+  create_entity_with_actuator,
+  get_test_device,
+  initialize_entity,
+  load_fixture_xml,
+)
+
+from mjlab.actuator import BuiltinPositionActuatorCfg, IdealPdActuatorCfg
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+@pytest.fixture(scope="module")
+def robot_xml():
+  return load_fixture_xml("floating_base_articulated")
+
+
+def test_ideal_pd_matches_builtin_at_rest(device, robot_xml):
+  """IdealPd and BuiltinPd produce equivalent actuator forces (qfrc_actuator)."""
+  kp, kv = 80.0, 10.0
+
+  ideal_entity = create_entity_with_actuator(
+    robot_xml,
+    IdealPdActuatorCfg(
+      target_names_expr=("joint.*",), effort_limit=100.0, stiffness=kp, damping=kv
+    ),
+  )
+  builtin_entity = create_entity_with_actuator(
+    robot_xml,
+    BuiltinPositionActuatorCfg(
+      target_names_expr=("joint.*",), effort_limit=100.0, stiffness=kp, damping=kv
+    ),
+  )
+
+  ideal_entity, ideal_sim = initialize_entity(ideal_entity, device)
+  builtin_entity, builtin_sim = initialize_entity(builtin_entity, device)
+
+  joint_pos = torch.tensor([[0.1, -0.05]], device=device)
+  joint_vel = torch.tensor([[0.0, 0.0]], device=device)
+  ideal_entity.write_joint_state_to_sim(joint_pos, joint_vel)
+  builtin_entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  pos_target = torch.tensor([[0.5, -0.3]], device=device)
+  vel_target = torch.tensor([[0.2, -0.1]], device=device)
+  ideal_entity.set_joint_position_target(pos_target)
+  ideal_entity.set_joint_velocity_target(vel_target)
+  ideal_entity.set_joint_effort_target(torch.zeros(1, 2, device=device))
+  builtin_entity.set_joint_position_target(pos_target)
+
+  ideal_entity.write_data_to_sim()
+  builtin_entity.write_data_to_sim()
+
+  joint_v_adr = ideal_entity.indexing.joint_v_adr
+  ideal_qfrc = ideal_sim.data.qfrc_actuator[0, joint_v_adr]
+  builtin_qfrc = builtin_sim.data.qfrc_actuator[0, joint_v_adr]
+
+  assert torch.allclose(ideal_qfrc, builtin_qfrc, rtol=1e-4, atol=1e-5)
+
+
+def test_ideal_pd_matches_builtin_with_velocity(device, robot_xml):
+  """IdealPd and BuiltinPd produce equivalent damping forces with nonzero vel."""
+  kp, kv = 80.0, 10.0
+
+  ideal_entity = create_entity_with_actuator(
+    robot_xml,
+    IdealPdActuatorCfg(
+      target_names_expr=("joint.*",), effort_limit=100.0, stiffness=kp, damping=kv
+    ),
+  )
+  builtin_entity = create_entity_with_actuator(
+    robot_xml,
+    BuiltinPositionActuatorCfg(
+      target_names_expr=("joint.*",), effort_limit=100.0, stiffness=kp, damping=kv
+    ),
+  )
+
+  ideal_entity, ideal_sim = initialize_entity(ideal_entity, device)
+  builtin_entity, builtin_sim = initialize_entity(builtin_entity, device)
+
+  joint_pos = torch.tensor([[0.2, -0.1]], device=device)
+  joint_vel = torch.tensor([[0.8, -0.5]], device=device)
+  ideal_entity.write_joint_state_to_sim(joint_pos, joint_vel)
+  builtin_entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  pos_target = torch.tensor([[0.5, 0.1]], device=device)
+  vel_target = torch.tensor([[0.3, -0.2]], device=device)
+  ideal_entity.set_joint_position_target(pos_target)
+  ideal_entity.set_joint_velocity_target(vel_target)
+  ideal_entity.set_joint_effort_target(torch.zeros(1, 2, device=device))
+  builtin_entity.set_joint_position_target(pos_target)
+
+  ideal_entity.write_data_to_sim()
+  builtin_entity.write_data_to_sim()
+
+  joint_v_adr = ideal_entity.indexing.joint_v_adr
+  ideal_qfrc = ideal_sim.data.qfrc_actuator[0, joint_v_adr]
+  builtin_qfrc = builtin_sim.data.qfrc_actuator[0, joint_v_adr]
+
+  assert torch.allclose(ideal_qfrc, builtin_qfrc, rtol=1e-4, atol=1e-5)
+
+
+def test_ideal_pd_with_feedforward_effort(device, robot_xml):
+  """IdealPd adds feedforward effort to PD output."""
+  kp, kv = 50.0, 5.0
+
+  ideal_entity = create_entity_with_actuator(
+    robot_xml,
+    IdealPdActuatorCfg(
+      target_names_expr=("joint.*",), effort_limit=100.0, stiffness=kp, damping=kv
+    ),
+  )
+
+  ideal_entity, ideal_sim = initialize_entity(ideal_entity, device)
+
+  joint_pos = torch.tensor([[0.5, 0.0]], device=device)
+  joint_vel = torch.tensor([[0.0, 0.0]], device=device)
+  ideal_entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  ideal_entity.set_joint_position_target(joint_pos)
+  ideal_entity.set_joint_velocity_target(joint_vel)
+  ideal_entity.set_joint_effort_target(torch.tensor([[2.0, -1.0]], device=device))
+  ideal_entity.write_data_to_sim()
+
+  ideal_ctrl = ideal_sim.data.ctrl[0]
+  assert torch.allclose(ideal_ctrl, torch.tensor([2.0, -1.0], device=device))
+
+
+def test_ideal_pd_effort_clamping(device, robot_xml):
+  """IdealPd clamps computed torques to [-effort_limit, effort_limit]."""
+  kp, kv = 100.0, 10.0
+  effort_limit = 5.0
+
+  ideal_entity = create_entity_with_actuator(
+    robot_xml,
+    IdealPdActuatorCfg(
+      target_names_expr=("joint.*",),
+      effort_limit=effort_limit,
+      stiffness=kp,
+      damping=kv,
+    ),
+  )
+
+  ideal_entity, ideal_sim = initialize_entity(ideal_entity, device)
+
+  joint_pos = torch.tensor([[0.0, 0.0]], device=device)
+  joint_vel = torch.tensor([[0.0, 0.0]], device=device)
+  ideal_entity.write_joint_state_to_sim(joint_pos, joint_vel)
+
+  ideal_entity.set_joint_position_target(torch.tensor([[1.0, -1.0]], device=device))
+  ideal_entity.set_joint_velocity_target(torch.zeros(1, 2, device=device))
+  ideal_entity.set_joint_effort_target(torch.zeros(1, 2, device=device))
+  ideal_entity.write_data_to_sim()
+
+  ideal_ctrl = ideal_sim.data.ctrl[0]
+  assert torch.allclose(
+    ideal_ctrl, torch.tensor([effort_limit, -effort_limit], device=device)
+  )
diff --git a/tests/test_perlin_terrain.py b/tests/test_perlin_terrain.py
new file mode 100644
index 0000000..0a9c8de
--- /dev/null
+++ b/tests/test_perlin_terrain.py
@@ -0,0 +1,109 @@
+"""Tests for Perlin noise terrain generation."""
+
+import mujoco
+import numpy as np
+import pytest
+
+from mjlab.terrains.heightfield_terrains import HfPerlinNoiseTerrainCfg
+
+
+@pytest.fixture
+def rng() -> np.random.Generator:
+  return np.random.default_rng(42)
+
+
+def test_perlin_terrain_generation(rng: np.random.Generator):
+  """Verify that Perlin noise terrain generates a valid TerrainOutput."""
+  spec = mujoco.MjSpec()
+  spec.worldbody.add_body(name="terrain")
+
+  cfg = HfPerlinNoiseTerrainCfg(
+    proportion=1.0,
+    size=(10.0, 10.0),
+    height_range=(0.1, 0.5),
+    octaves=4,
+    persistence=0.5,
+    lacunarity=2.0,
+    scale=10.0,
+    horizontal_scale=0.1,
+    resolution=0.1,
+  )
+
+  output = cfg.function(difficulty=0.5, spec=spec, rng=rng)
+
+  # Basic checks for TerrainOutput.
+  assert output.origin.shape == (3,)
+  assert len(output.geometries) == 1
+  assert output.geometries[0].geom is not None
+  assert output.geometries[0].hfield is not None
+
+  # Check hfield size.
+  # size = [x/2, y/2, max_height, base_thickness]
+  hfield = output.geometries[0].hfield
+  assert hfield.size[0] == 5.0
+  assert hfield.size[1] == 5.0
+  assert hfield.size[2] > 0  # max height should be positive
+
+  # Check hfield data.
+  data = np.asarray(hfield.userdata)
+  assert len(data) == 100 * 100  # (10.0/0.1) * (10.0/0.1)
+  assert np.all(data >= 0.0)
+  assert np.all(data <= 1.0)
+  assert np.max(data) > 0.0  # it should not be flat 0
+
+  # Check if height variation is present.
+  assert np.min(data) < np.max(data)
+
+
+def test_perlin_terrain_resolution(rng: np.random.Generator):
+  """Verify that higher resolution increases pixel count."""
+  spec = mujoco.MjSpec()
+  spec.worldbody.add_body(name="terrain")
+
+  cfg = HfPerlinNoiseTerrainCfg(
+    proportion=1.0,
+    size=(10.0, 10.0),
+    height_range=(0.1, 0.5),
+    horizontal_scale=0.1,
+    resolution=0.05,  # 200 pixels
+  )
+
+  output = cfg.function(difficulty=0.5, spec=spec, rng=rng)
+  hfield = output.geometries[0].hfield
+  assert hfield is not None
+  # (10.0 / 0.05) = 200
+  assert hfield.nrow == 200
+  assert hfield.ncol == 200
+  assert len(hfield.userdata) == 200 * 200
+
+
+def test_perlin_terrain_with_border(rng: np.random.Generator):
+  """Verify Perlin noise terrain with a border."""
+  spec = mujoco.MjSpec()
+  spec.worldbody.add_body(name="terrain")
+
+  cfg = HfPerlinNoiseTerrainCfg(
+    proportion=1.0,
+    size=(10.0, 10.0),
+    height_range=(0.1, 0.5),
+    border_width=2.0,
+    horizontal_scale=0.1,
+    resolution=0.1,
+  )
+
+  output = cfg.function(difficulty=0.5, spec=spec, rng=rng)
+  hfield = output.geometries[0].hfield
+  assert hfield is not None
+  data = np.asarray(hfield.userdata).reshape(100, 100)
+
+  # Border pixels: 2.0 / 0.1 = 20
+  border_pixels = 20
+  top_border = data[:border_pixels, :]
+  bottom_border = data[-border_pixels:, :]
+  left_border = data[:, :border_pixels]
+  right_border = data[:, -border_pixels:]
+
+  assert np.all(top_border == top_border[0, 0])
+  assert np.all(bottom_border == bottom_border[0, 0])
+  assert np.all(left_border == left_border[0, 0])
+  assert np.all(right_border == right_border[0, 0])
diff --git a/tests/test_projected_gravity_sensor.py b/tests/test_projected_gravity_sensor.py
new file mode 100644
index 0000000..738d7e5
--- /dev/null
+++ b/tests/test_projected_gravity_sensor.py
@@ -0,0 +1,213 @@
+"""Tests for sensor-based projected gravity (framezaxis up-vector sensor).
+
+The shipped robots expose a ``framezaxis`` sensor that outputs the world Z-axis in the
+IMU site frame; negating it gives projected gravity. These tests check the sensor (and
+the ``projected_gravity_from_sensor`` observation that wraps it) against an independent
+ground-truth computation, and verify that -- unlike the entity-data
+``projected_gravity_b`` -- it tracks the IMU site orientation, which is what makes IMU
+mounting domain randomization observable.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import TYPE_CHECKING, cast
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.entity import EntityCfg
+from mjlab.envs.mdp import dr
+from mjlab.envs.mdp.observations import projected_gravity_from_sensor
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.scene import Scene, SceneCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+# Gravity points along world -Z; projected gravity is this expressed in a body frame.
+_GRAVITY_DIR_W = (0.0, 0.0, -1.0)
+
+
+def _quat_to_mat(q: tuple[float, float, float, float]) -> torch.Tensor:
+  """Rotation matrix from a (w, x, y, z) quaternion. Independent of MuJoCo/mjlab."""
+  w, x, y, z = q
+  return torch.tensor(
+    [
+      [1 - 2 * (y * y + z * z), 2 * (x * y - w * z), 2 * (x * z + w * y)],
+      [2 * (x * y + w * z), 1 - 2 * (x * x + z * z), 2 * (y * z - w * x)],
+      [2 * (x * z - w * y), 2 * (y * z + w * x), 1 - 2 * (x * x + y * y)],
+    ],
+    dtype=torch.float64,
+  )
+
+
+def _expected_projected_gravity(q: tuple[float, float, float, float]) -> torch.Tensor:
+  """Ground-truth projected gravity for a body with world orientation ``q``.
+
+  proj = R(q)^T @ g_world, computed from an explicit rotation matrix so it does not
+  share a code path with the sensor or with ``projected_gravity_b``.
+  """
+  g_w = torch.tensor(_GRAVITY_DIR_W, dtype=torch.float64)
+  return _quat_to_mat(q).T @ g_w
+
+
+class Env:
+  """Minimal env stub for driving observation and dr functions in tests."""
+
+  def __init__(self, scene, sim, device):
+    self.scene = scene
+    self.sim = sim
+    self.num_envs = scene.num_envs
+    self.device = device
+
+
+def _make_env(scene, sim, device) -> ManagerBasedRlEnv:
+  """Build the env stub, typed as the real env for the functions under test."""
+  return cast("ManagerBasedRlEnv", Env(scene, sim, device))
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+def _robot_xml(site_euler: str = "0 0 0") -> str:
+  """Free-floating box with an IMU site and the framezaxis up-vector sensor."""
+  return f"""
+    <mujoco>
+      <worldbody>
+        <body name="base" pos="0 0 1">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="5.0"/>
+          <site name="imu" pos="0.05 0 0" euler="{site_euler}"/>
+        </body>
+      </worldbody>
+      <sensor>
+        <framezaxis name="imu_upvector" objtype="body" objname="world"
+                    reftype="site" refname="imu"/>
+      </sensor>
+    </mujoco>
+  """
+
+
+def _build(xml: str, device: str, num_envs: int = 2):
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(xml))
+  scene = Scene(
+    SceneCfg(num_envs=num_envs, env_spacing=3.0, entities={"robot": entity_cfg}),
+    device,
+  )
+  model = scene.compile()
+  sim = Simulation(
+    num_envs=num_envs, cfg=SimulationCfg(njmax=20), model=model, device=device
+  )
+  scene.initialize(sim.mj_model, sim.model, sim.data)
+  return scene, sim
+
+
+def _set_root_quat(robot, q: tuple[float, float, float, float], device: str) -> None:
+  root_state = robot.data.default_root_state.clone()
+  root_state[:, 3:7] = torch.tensor(q, device=device, dtype=root_state.dtype)
+  robot.write_root_state_to_sim(root_state)
+
+
+def test_sensor_matches_ground_truth_when_site_aligned(device):
+  """Sensor and entity both equal hand-computed projected gravity for a tilted base."""
+  scene, sim = _build(_robot_xml(), device)
+  robot = scene["robot"]
+
+  # Compose a 0.6 rad roll with a 0.3 rad pitch into a single root quaternion.
+  ax = (math.cos(0.3), math.sin(0.3), 0.0, 0.0)
+  ay = (math.cos(0.15), 0.0, math.sin(0.15), 0.0)
+  q = (
+    ax[0] * ay[0] - ax[1] * ay[1] - ax[2] * ay[2] - ax[3] * ay[3],
+    ax[0] * ay[1] + ax[1] * ay[0] + ax[2] * ay[3] - ax[3] * ay[2],
+    ax[0] * ay[2] - ax[1] * ay[3] + ax[2] * ay[0] + ax[3] * ay[1],
+    ax[0] * ay[3] + ax[1] * ay[2] - ax[2] * ay[1] + ax[3] * ay[0],
+  )
+  _set_root_quat(robot, q, device)
+  sim.forward()
+
+  expected = _expected_projected_gravity(q).to(device=device, dtype=torch.float32)
+  # Guard against a vacuous pass: the tilt must actually move gravity off straight-down.
+  straight_down = torch.tensor(_GRAVITY_DIR_W, device=device)
+  assert (expected - straight_down).abs().max() > 0.3
+
+  sensor_grav = -scene["robot/imu_upvector"].data
+  entity_grav = robot.data.projected_gravity_b
+  torch.testing.assert_close(sensor_grav[0], expected, atol=1e-5, rtol=0)
+  torch.testing.assert_close(entity_grav[0], expected, atol=1e-5, rtol=0)
+
+
+def test_observation_fn_tracks_site_orientation(device):
+  """The observation fn reflects IMU site tilt; the entity-data version does not.
+
+  With the base upright but the IMU site rolled 30 deg about x, projected gravity in the
+  site frame is (0, -sin30, -cos30). The entity-data version stays straight-down because
+  it uses the root body orientation and is blind to the site.
+  """
+  scene_rot, sim_rot = _build(_robot_xml(site_euler="30 0 0"), device)
+  scene_flat, sim_flat = _build(_robot_xml(site_euler="0 0 0"), device)
+  sim_rot.forward()
+  sim_flat.forward()
+
+  # Drive through the actual shipped observation function, not the raw sensor.
+  env_rot = _make_env(scene_rot, sim_rot, device)
+  env_flat = _make_env(scene_flat, sim_flat, device)
+  grav_rot = projected_gravity_from_sensor(env_rot, "robot/imu_upvector")
+  grav_flat = projected_gravity_from_sensor(env_flat, "robot/imu_upvector")
+
+  expected_rot = torch.tensor(
+    [0.0, -math.sin(math.radians(30)), -math.cos(math.radians(30))], device=device
+  )
+  straight_down = torch.tensor(_GRAVITY_DIR_W, device=device)
+  torch.testing.assert_close(grav_rot[0], expected_rot, atol=1e-5, rtol=0)
+  torch.testing.assert_close(grav_flat[0], straight_down, atol=1e-5, rtol=0)
+
+  # The entity-data version is unchanged by the site rotation (so it cannot be used to
+  # observe IMU mounting randomization), confirming why the sensor path is needed.
+  entity_rot = scene_rot["robot"].data.projected_gravity_b
+  torch.testing.assert_close(entity_rot[0], straight_down, atol=1e-5, rtol=0)
+
+
+@pytest.mark.filterwarnings(
+  "ignore:Use of index_put_ on expanded tensors is deprecated:UserWarning"
+)
+def test_site_quat_randomization_changes_sensor(device):
+  """The full DR path: running ``dr.site_quat`` perturbs the gravity observation.
+
+  This is what the G1 example configs rely on -- randomizing the IMU site orientation
+  must show up in the sensor-based projected gravity, per-environment.
+  """
+  scene, sim = _build(_robot_xml(), device, num_envs=4)
+  sim.expand_model_fields(("site_quat",))
+  env = _make_env(scene, sim, device)
+
+  sim.forward()
+  straight_down = torch.tensor(_GRAVITY_DIR_W, device=device)
+  before = projected_gravity_from_sensor(env, "robot/imu_upvector").clone()
+  # Upright base + identity site quat => straight-down gravity in every env.
+  torch.testing.assert_close(before, straight_down.expand_as(before), atol=1e-5, rtol=0)
+
+  torch.manual_seed(0)
+  dr.site_quat(
+    env,
+    env_ids=None,
+    roll_range=(-0.3, 0.3),
+    pitch_range=(-0.3, 0.3),
+    yaw_range=(-0.3, 0.3),
+    asset_cfg=SceneEntityCfg("robot", site_names=("imu",)),
+  )
+  sim.forward()
+  after = projected_gravity_from_sensor(env, "robot/imu_upvector")
+
+  # Randomization moved the reading off straight-down and made it env-dependent.
+  assert (after - straight_down).abs().max() > 0.05
+  assert not torch.allclose(after, before, atol=1e-3)
+  assert torch.unique(after, dim=0).shape[0] >= 2
+  # The perturbation is a rotation, so gravity stays a unit vector.
+  norms = torch.linalg.norm(after, dim=-1)
+  torch.testing.assert_close(norms, torch.ones_like(norms), atol=1e-5, rtol=0)
diff --git a/tests/test_raycast_sensor.py b/tests/test_raycast_sensor.py
new file mode 100644
index 0000000..9e904df
--- /dev/null
+++ b/tests/test_raycast_sensor.py
@@ -0,0 +1,1244 @@
+"""Tests for raycast_sensor.py."""
+
+from __future__ import annotations
+
+import math
+
+import pytest
+import torch
+from conftest import get_test_device, make_scene_and_sim
+
+from mjlab.envs.mdp.observations import height_scan
+from mjlab.sensor import (
+  GridPatternCfg,
+  ObjRef,
+  PinholeCameraPatternCfg,
+  RayCastData,
+  RayCastSensorCfg,
+  RingPatternCfg,
+)
+from mjlab.sensor.raycast_sensor import _geom_groups_to_vec6
+from mjlab.sim import MujocoCfg, SimulationCfg
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+def test_basic_raycast_hit_detection(robot_with_floor_xml, device):
+  """Verify rays detect the ground plane and return correct distances."""
+  raycast_cfg = RayCastSensorCfg(
+    name="terrain_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(
+      size=(0.5, 0.5), resolution=0.25, direction=(0.0, 0.0, -1.0)
+    ),
+    max_distance=10.0,
+  )
+
+  scene, sim = make_scene_and_sim(
+    device, robot_with_floor_xml, sensors=(raycast_cfg,), num_envs=2
+  )
+
+  sensor = scene["terrain_scan"]
+  sim.step()
+  sim.sense()
+  data = sensor.data
+
+  assert isinstance(data, RayCastData)
+  assert data.distances.shape[0] == 2  # num_envs
+  assert data.distances.shape[1] == sensor.num_rays
+  assert data.normals_w.shape == (2, sensor.num_rays, 3)
+
+  # All rays should hit the floor (distance > 0).
+  assert torch.all(data.distances >= 0)
+
+  # Distance should be approximately 2m (body at z=2, floor at z=0).
+  assert torch.allclose(data.distances, torch.full_like(data.distances, 2.0), atol=0.1)
+
+
+def test_raycast_normals_point_up(robot_with_floor_xml, device):
+  """Verify surface normals point upward when hitting a horizontal floor."""
+  raycast_cfg = RayCastSensorCfg(
+    name="terrain_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(
+      size=(0.3, 0.3), resolution=0.15, direction=(0.0, 0.0, -1.0)
+    ),
+    max_distance=10.0,
+  )
+
+  scene, sim = make_scene_and_sim(device, robot_with_floor_xml, sensors=(raycast_cfg,))
+
+  sensor = scene["terrain_scan"]
+  sim.step()
+  sim.sense()
+  data = sensor.data
+
+  # Normals should point up (+Z) for a horizontal floor.
+  expected = torch.zeros_like(data.normals_w)
+  expected[:, :, 2] = 1.0
+  assert torch.allclose(data.normals_w, expected)
+
+
+def test_raycast_miss_returns_negative_one(device):
+  """Verify rays that miss return distance of -1."""
+  no_floor_xml = """
+    <mujoco>
+      <worldbody>
+        <body name="base" pos="0 0 2">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="5.0"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  raycast_cfg = RayCastSensorCfg(
+    name="terrain_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(
+      size=(0.3, 0.3), resolution=0.15, direction=(0.0, 0.0, -1.0)
+    ),
+    max_distance=10.0,
+    exclude_parent_body=True,
+  )
+
+  scene, sim = make_scene_and_sim(device, no_floor_xml, sensors=(raycast_cfg,))
+
+  sensor = scene["terrain_scan"]
+  sim.step()
+  sim.sense()
+  data = sensor.data
+
+  # All rays should miss (distance = -1).
+  assert torch.all(data.distances == -1)
+
+
+def test_raycast_exclude_parent_body(robot_with_floor_xml, device):
+  """Verify parent body is excluded from ray intersection when configured."""
+  raycast_cfg = RayCastSensorCfg(
+    name="terrain_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(size=(0.1, 0.1), resolution=0.1, direction=(0.0, 0.0, -1.0)),
+    max_distance=10.0,
+    exclude_parent_body=True,
+  )
+
+  scene, sim = make_scene_and_sim(device, robot_with_floor_xml, sensors=(raycast_cfg,))
+
+  sensor = scene["terrain_scan"]
+  sim.step()
+  sim.sense()
+  data = sensor.data
+
+  # Rays should hit the floor, not the parent body geom.
+  # Floor is at z=0, body is at z=2, so distance should be ~2m.
+  assert torch.allclose(data.distances, torch.full_like(data.distances, 2.0), atol=0.1)
+
+
+def test_raycast_include_geom_groups(device):
+  """Verify include_geom_groups filters which geoms are hit."""
+  groups_xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1" pos="0 0 0" group="0"/>
+        <geom name="platform" type="box" size="1 1 0.1" pos="0 0 1" group="1"/>
+        <body name="base" pos="0 0 3">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.1" mass="1.0"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  # Only include group 0 (floor) - should skip the platform in group 1.
+  raycast_cfg = RayCastSensorCfg(
+    name="group_filter_test",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(size=(0.0, 0.0), resolution=0.1, direction=(0.0, 0.0, -1.0)),
+    max_distance=10.0,
+    include_geom_groups=(0,),
+  )
+
+  scene, sim = make_scene_and_sim(device, groups_xml, sensors=(raycast_cfg,))
+
+  sensor = scene["group_filter_test"]
+  sim.step()
+  sim.sense()
+  data = sensor.data
+
+  # Should hit floor at z=0, not platform at z=1.1. Distance from z=3 to z=0 is 3m.
+  assert torch.allclose(data.distances, torch.full_like(data.distances, 3.0), atol=0.1)
+
+  # Now test with group 1 included - should hit platform instead.
+  raycast_cfg_group1 = RayCastSensorCfg(
+    name="group1_test",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(size=(0.0, 0.0), resolution=0.1, direction=(0.0, 0.0, -1.0)),
+    max_distance=10.0,
+    include_geom_groups=(1,),
+  )
+
+  scene2, sim2 = make_scene_and_sim(device, groups_xml, sensors=(raycast_cfg_group1,))
+
+  sensor2 = scene2["group1_test"]
+  sim2.step()
+  sim2.sense()
+  data2 = sensor2.data
+
+  # Should hit platform at z=1.1. Distance from z=3 to z=1.1 is 1.9m.
+  assert torch.allclose(
+    data2.distances, torch.full_like(data2.distances, 1.9), atol=0.1
+  )
+
+
+def test_raycast_frame_attachment_geom(device):
+  """Verify rays can be attached to a geom frame."""
+  geom_xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1" pos="0 0 0"/>
+        <body name="base" pos="0 0 2">
+          <freejoint name="free_joint"/>
+          <geom name="sensor_mount" type="box" size="0.1 0.1 0.05" pos="0 0 -0.05"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  raycast_cfg = RayCastSensorCfg(
+    name="geom_scan",
+    frame=ObjRef(type="geom", name="sensor_mount", entity="robot"),
+    pattern=GridPatternCfg(size=(0.2, 0.2), resolution=0.1, direction=(0.0, 0.0, -1.0)),
+    max_distance=10.0,
+  )
+
+  scene, sim = make_scene_and_sim(device, geom_xml, sensors=(raycast_cfg,))
+
+  sensor = scene["geom_scan"]
+  sim.step()
+  sim.sense()
+  data = sensor.data
+
+  assert isinstance(data, RayCastData)
+  # Geom is at z=1.95 (body at z=2, geom offset -0.05), floor at z=0.
+  assert torch.allclose(data.distances, torch.full_like(data.distances, 1.95), atol=0.1)
+
+
+def test_raycast_frame_attachment_site(robot_with_floor_xml, device):
+  """Verify rays can be attached to a site frame."""
+  raycast_cfg = RayCastSensorCfg(
+    name="site_scan",
+    frame=ObjRef(type="site", name="base_site", entity="robot"),
+    pattern=GridPatternCfg(size=(0.2, 0.2), resolution=0.1, direction=(0.0, 0.0, -1.0)),
+    max_distance=10.0,
+  )
+
+  scene, sim = make_scene_and_sim(device, robot_with_floor_xml, sensors=(raycast_cfg,))
+
+  sensor = scene["site_scan"]
+  sim.step()
+  sim.sense()
+  data = sensor.data
+
+  assert isinstance(data, RayCastData)
+  # Site is at z=1.9 (body at z=2, site offset -0.1), floor at z=0.
+  assert torch.allclose(data.distances, torch.full_like(data.distances, 1.9), atol=0.1)
+
+
+def test_raycast_grid_pattern_num_rays(device):
+  """Verify grid pattern generates correct number of rays."""
+  simple_xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1"/>
+        <body name="base" pos="0 0 1">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.1"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  # Grid: size=(1.0, 0.5), resolution=0.5.
+  # X: from -0.5 to 0.5 step 0.5 -> 3 points.
+  # Y: from -0.25 to 0.25 step 0.5 -> 2 points.
+  # Total: 3 * 2 = 6 rays.
+  raycast_cfg = RayCastSensorCfg(
+    name="grid_test",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(size=(1.0, 0.5), resolution=0.5),
+  )
+
+  scene, sim = make_scene_and_sim(device, simple_xml, sensors=(raycast_cfg,))
+
+  sensor = scene["grid_test"]
+  assert sensor.num_rays == 6
+
+
+def test_raycast_different_direction(device):
+  """Verify rays work with non-default direction."""
+  wall_xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="wall" type="box" size="0.1 5 5" pos="2 0 2"/>
+        <body name="base" pos="0 0 2">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.1"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  raycast_cfg = RayCastSensorCfg(
+    name="forward_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(size=(0.2, 0.2), resolution=0.1, direction=(1.0, 0.0, 0.0)),
+    max_distance=10.0,
+  )
+
+  scene, sim = make_scene_and_sim(device, wall_xml, sensors=(raycast_cfg,))
+
+  sensor = scene["forward_scan"]
+  sim.step()
+  sim.sense()
+  data = sensor.data
+
+  # Wall is at x=1.9 (wall center at x=2, size 0.1), body at x=0.
+  # Distance should be ~1.9m.
+  assert torch.allclose(data.distances, torch.full_like(data.distances, 1.9), atol=0.1)
+
+  # Normal should point in -X direction (toward the body).
+  assert torch.allclose(
+    data.normals_w[:, :, 0], -torch.ones_like(data.normals_w[:, :, 0]), atol=0.01
+  )
+
+
+def test_raycast_error_on_invalid_frame_type(device):
+  """Verify ValueError is raised for invalid frame type."""
+  simple_xml = """
+    <mujoco>
+      <worldbody>
+        <body name="base"><geom type="sphere" size="0.1"/></body>
+      </worldbody>
+    </mujoco>
+  """
+  raycast_cfg = RayCastSensorCfg(
+    name="invalid",
+    frame=ObjRef(type="joint", name="some_joint", entity="robot"),
+    pattern=GridPatternCfg(size=(0.1, 0.1), resolution=0.1),
+  )
+  with pytest.raises(ValueError, match="must be 'body', 'site', or 'geom'"):
+    make_scene_and_sim(device, simple_xml, sensors=(raycast_cfg,))
+
+
+def test_raycast_hit_pos_w_correctness(robot_with_floor_xml, device):
+  """Verify hit_pos_w returns correct world-space hit positions."""
+  raycast_cfg = RayCastSensorCfg(
+    name="terrain_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(size=(0.4, 0.4), resolution=0.2, direction=(0.0, 0.0, -1.0)),
+    max_distance=10.0,
+  )
+
+  scene, sim = make_scene_and_sim(device, robot_with_floor_xml, sensors=(raycast_cfg,))
+
+  sensor = scene["terrain_scan"]
+  sim.step()
+  sim.sense()
+  data = sensor.data
+
+  # All hit positions should be on the floor (z=0).
+  assert torch.allclose(
+    data.hit_pos_w[:, :, 2], torch.zeros_like(data.hit_pos_w[:, :, 2]), atol=0.01
+  )
+
+  # Hit positions X and Y should match the ray grid pattern offset from body origin.
+  # Body is at (0, 0, 2), grid is 0.4x0.4 with 0.2 resolution = 3x3 = 9 rays.
+  # X positions should be in range [-0.2, 0.2], Y positions in range [-0.2, 0.2].
+  assert torch.all(data.hit_pos_w[:, :, 0] >= -0.3)
+  assert torch.all(data.hit_pos_w[:, :, 0] <= 0.3)
+  assert torch.all(data.hit_pos_w[:, :, 1] >= -0.3)
+  assert torch.all(data.hit_pos_w[:, :, 1] <= 0.3)
+
+
+def test_raycast_max_distance_clamping(device):
+  """Verify hits beyond max_distance are reported as misses."""
+  far_floor_xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1" pos="0 0 0"/>
+        <body name="base" pos="0 0 5">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.1" mass="1.0"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  raycast_cfg = RayCastSensorCfg(
+    name="short_range",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(size=(0.2, 0.2), resolution=0.1, direction=(0.0, 0.0, -1.0)),
+    max_distance=3.0,
+  )
+
+  scene, sim = make_scene_and_sim(device, far_floor_xml, sensors=(raycast_cfg,))
+
+  sensor = scene["short_range"]
+  sim.step()
+  sim.sense()
+  data = sensor.data
+
+  # All rays should miss (floor is beyond max_distance).
+  assert torch.all(data.distances == -1)
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="Likely bug on CPU MjWarp")
+def test_raycast_body_rotation_affects_rays(device):
+  """Verify rays rotate with the body frame."""
+  rotated_body_xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1" pos="0 0 0"/>
+        <body name="base" pos="0 0 2">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.1" mass="1.0"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  raycast_cfg = RayCastSensorCfg(
+    name="rotated_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(size=(0.0, 0.0), resolution=0.1, direction=(0.0, 0.0, -1.0)),
+    max_distance=10.0,
+  )
+
+  sim_cfg = SimulationCfg(mujoco=MujocoCfg(gravity=(0, 0, 0)), njmax=20)
+  scene, sim = make_scene_and_sim(
+    device, rotated_body_xml, sensors=(raycast_cfg,), sim_cfg=sim_cfg
+  )
+
+  sensor = scene["rotated_scan"]
+
+  # First, verify baseline: unrotated body, rays hit floor at ~2m.
+  sim.step()
+  scene.update(dt=sim.cfg.mujoco.timestep)
+  sim.sense()
+  data_unrotated = sensor.data
+  assert torch.allclose(
+    data_unrotated.distances, torch.full_like(data_unrotated.distances, 2.0), atol=0.1
+  )
+
+  # Now tilt body 45 degrees around X axis.
+  # Ray direction -Z in body frame becomes diagonal in world frame.
+  # Distance to floor should be 2 / cos(45) = 2 * sqrt(2) ≈ 2.83m.
+  angle = math.pi / 4
+  quat = [math.cos(angle / 2), math.sin(angle / 2), 0, 0]  # w, x, y, z
+  sim.data.qpos[0, 3:7] = torch.tensor(quat, device=device)
+  sim.step()
+  scene.update(dt=sim.cfg.mujoco.timestep)
+  sim.sense()
+  data_rotated = sensor.data
+
+  expected_distance = 2.0 / math.cos(angle)  # ~2.83m
+  assert torch.allclose(
+    data_rotated.distances,
+    torch.full_like(data_rotated.distances, expected_distance),
+    atol=0.15,
+  ), f"Expected ~{expected_distance:.2f}m, got {data_rotated.distances}"
+
+
+# ============================================================================
+# Pinhole Camera Pattern Tests
+# ============================================================================
+
+
+def test_pinhole_camera_pattern_num_rays(device):
+  """Verify pinhole pattern generates width * height rays."""
+  simple_xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1"/>
+        <body name="base" pos="0 0 1">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.1"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  raycast_cfg = RayCastSensorCfg(
+    name="camera_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=PinholeCameraPatternCfg(width=16, height=12, fovy=74.0),
+  )
+
+  scene, sim = make_scene_and_sim(device, simple_xml, sensors=(raycast_cfg,))
+
+  sensor = scene["camera_scan"]
+  assert sensor.num_rays == 16 * 12
+
+
+def test_pinhole_from_intrinsic_matrix():
+  """Verify from_intrinsic_matrix creates correct config."""
+  # Intrinsic matrix with fx=500, fy=500, cx=320, cy=240.
+  intrinsic = [500.0, 0, 320, 0, 500.0, 240, 0, 0, 1]
+  width, height = 640, 480
+
+  cfg = PinholeCameraPatternCfg.from_intrinsic_matrix(intrinsic, width, height)
+
+  # Expected vertical FOV: 2 * atan(480 / (2 * 500)) = 2 * atan(0.48) ≈ 51.3 degrees.
+  fy = intrinsic[4]
+  expected_fov = 2 * math.atan(height / (2 * fy)) * 180 / math.pi
+  assert abs(cfg.fovy - expected_fov) < 0.1
+  assert cfg.width == width
+  assert cfg.height == height
+
+
+def test_pinhole_from_mujoco_camera(device):
+  """Verify pinhole pattern can be created from MuJoCo camera."""
+  # XML with a camera that has explicit resolution, sensorsize, and focal.
+  camera_xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1" pos="0 0 0"/>
+        <body name="base" pos="0 0 2">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.1" mass="1.0"/>
+          <camera name="depth_cam" pos="0 0 0" resolution="64 48"
+                  sensorsize="0.00389 0.00292" focal="0.00193 0.00193"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  # Use from_mujoco_camera() to get params from MuJoCo camera.
+  raycast_cfg = RayCastSensorCfg(
+    name="camera_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=PinholeCameraPatternCfg.from_mujoco_camera("robot/depth_cam"),
+    max_distance=10.0,
+  )
+
+  scene, sim = make_scene_and_sim(device, camera_xml, sensors=(raycast_cfg,))
+
+  sensor = scene["camera_scan"]
+  # Should have 64 * 48 = 3072 rays.
+  assert sensor.num_rays == 64 * 48
+
+  # Verify rays work.
+  sim.step()
+  sim.sense()
+  data = sensor.data
+  assert torch.all(data.distances >= 0)  # Should hit floor
+
+
+def test_pinhole_from_mujoco_camera_fovy_mode(device):
+  """Verify pinhole pattern works with MuJoCo camera using fovy (not sensorsize)."""
+  # XML with a camera using fovy mode (no sensorsize/focal).
+  camera_xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1" pos="0 0 0"/>
+        <body name="base" pos="0 0 2">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.1" mass="1.0"/>
+          <camera name="fovy_cam" pos="0 0 0" fovy="60" resolution="32 24"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  raycast_cfg = RayCastSensorCfg(
+    name="camera_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=PinholeCameraPatternCfg.from_mujoco_camera("robot/fovy_cam"),
+    max_distance=10.0,
+  )
+
+  scene, sim = make_scene_and_sim(device, camera_xml, sensors=(raycast_cfg,))
+
+  sensor = scene["camera_scan"]
+  # Should have 32 * 24 = 768 rays.
+  assert sensor.num_rays == 32 * 24
+
+  # Verify rays work.
+  sim.step()
+  sim.sense()
+  data = sensor.data
+  assert torch.all(data.distances >= 0)  # Should hit floor
+
+
+# ============================================================================
+# Ray Alignment Tests
+# ============================================================================
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="Likely bug on CPU MjWarp")
+def test_ray_alignment_yaw(device):
+  """Verify yaw alignment ignores pitch/roll."""
+  rotated_body_xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1" pos="0 0 0"/>
+        <body name="base" pos="0 0 2">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.1" mass="1.0"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  # With yaw alignment, tilting the body should NOT affect ray direction.
+  raycast_cfg = RayCastSensorCfg(
+    name="yaw_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(size=(0.0, 0.0), resolution=0.1, direction=(0.0, 0.0, -1.0)),
+    ray_alignment="yaw",
+    max_distance=10.0,
+  )
+
+  sim_cfg = SimulationCfg(mujoco=MujocoCfg(gravity=(0, 0, 0)), njmax=20)
+  scene, sim = make_scene_and_sim(
+    device, rotated_body_xml, sensors=(raycast_cfg,), sim_cfg=sim_cfg
+  )
+
+  sensor = scene["yaw_scan"]
+
+  # Baseline: unrotated.
+  sim.step()
+  scene.update(dt=sim.cfg.mujoco.timestep)
+  sim.sense()
+  data_unrotated = sensor.data
+  baseline_dist = data_unrotated.distances.clone()
+
+  # Tilt body 45 degrees around X axis.
+  angle = math.pi / 4
+  quat = [math.cos(angle / 2), math.sin(angle / 2), 0, 0]  # w, x, y, z
+  sim.data.qpos[0, 3:7] = torch.tensor(quat, device=device)
+  sim.step()
+  scene.update(dt=sim.cfg.mujoco.timestep)
+  sim.sense()
+  data_tilted = sensor.data
+
+  # With yaw alignment, distance should remain ~2m (not change due to tilt).
+  assert torch.allclose(data_tilted.distances, baseline_dist, atol=0.1), (
+    f"Expected ~2m, got {data_tilted.distances}"
+  )
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="Likely bug on CPU MjWarp")
+def test_ray_alignment_world(device):
+  """Verify world alignment keeps rays fixed."""
+  rotated_body_xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1" pos="0 0 0"/>
+        <body name="base" pos="0 0 2">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.1" mass="1.0"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  # With world alignment, rotating body should NOT affect ray direction.
+  raycast_cfg = RayCastSensorCfg(
+    name="world_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(size=(0.0, 0.0), resolution=0.1, direction=(0.0, 0.0, -1.0)),
+    ray_alignment="world",
+    max_distance=10.0,
+  )
+
+  sim_cfg = SimulationCfg(mujoco=MujocoCfg(gravity=(0, 0, 0)), njmax=20)
+  scene, sim = make_scene_and_sim(
+    device, rotated_body_xml, sensors=(raycast_cfg,), sim_cfg=sim_cfg
+  )
+
+  sensor = scene["world_scan"]
+
+  # Baseline: unrotated.
+  sim.step()
+  scene.update(dt=sim.cfg.mujoco.timestep)
+  sim.sense()
+  data_unrotated = sensor.data
+  baseline_dist = data_unrotated.distances.clone()
+
+  # Rotate body 90 degrees around Z (yaw), then tilt 45 degrees around X.
+  # With world alignment, distance should still be ~2m.
+  yaw_angle = math.pi / 2
+  pitch_angle = math.pi / 4
+  # Compose quaternions: yaw then pitch.
+  cy, sy = math.cos(yaw_angle / 2), math.sin(yaw_angle / 2)
+  cp, sp = math.cos(pitch_angle / 2), math.sin(pitch_angle / 2)
+  # q_yaw = [cy, 0, 0, sy], q_pitch = [cp, sp, 0, 0]
+  # q = q_pitch * q_yaw
+  qw = cp * cy
+  qx = sp * cy
+  qy = sp * sy
+  qz = cp * sy
+  sim.data.qpos[0, 3:7] = torch.tensor([qw, qx, qy, qz], device=device)
+  sim.step()
+  scene.update(dt=sim.cfg.mujoco.timestep)
+  sim.sense()
+  data_rotated = sensor.data
+
+  # With world alignment, distance should remain ~2m.
+  assert torch.allclose(data_rotated.distances, baseline_dist, atol=0.1), (
+    f"Expected ~2m, got {data_rotated.distances}"
+  )
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="Likely bug on CPU MjWarp")
+def test_ray_alignment_yaw_singularity(device):
+  """Test yaw alignment handles 90 degree pitch singularity correctly.
+
+  With yaw alignment, rays should maintain their pattern regardless of
+  body pitch. At 90 degree pitch, the body's X-axis is vertical, making
+  yaw extraction ambiguous. The implementation uses Y-axis fallback to
+  produce a valid yaw rotation.
+
+  This test verifies that distances at 90 degree pitch match the
+  baseline (0 degree pitch).
+  """
+  xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1" pos="0 0 0"/>
+        <body name="base" pos="0 0 2">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.1" mass="1.0"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  # Use grid pattern with diagonal direction - has X component to
+  # expose singularity. Direction [1, 0, -1] points forward and down
+  # at 45 degrees.
+  raycast_cfg = RayCastSensorCfg(
+    name="yaw_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(size=(0.0, 0.0), resolution=0.1, direction=(1.0, 0.0, -1.0)),
+    ray_alignment="yaw",
+    max_distance=10.0,
+  )
+
+  sim_cfg = SimulationCfg(mujoco=MujocoCfg(gravity=(0, 0, 0)), njmax=20)
+  scene, sim = make_scene_and_sim(device, xml, sensors=(raycast_cfg,), sim_cfg=sim_cfg)
+
+  sensor = scene["yaw_scan"]
+
+  # Baseline: no rotation. Ray at 45 degrees from height 2m hits floor
+  # at x=2, z=0.
+  sim.step()
+  scene.update(dt=sim.cfg.mujoco.timestep)
+  sim.sense()
+  baseline_hit_pos = sensor.data.hit_pos_w.clone()
+  # Ray goes diagonally +X and -Z, starting from (0,0,2), should hit
+  # floor at (2, 0, 0).
+  assert torch.allclose(
+    baseline_hit_pos[0, 0, 0],
+    torch.tensor(2.0, device=device),
+    atol=0.1,
+  ), f"Baseline X hit should be ~2, got {baseline_hit_pos[0, 0, 0]}"
+  assert torch.allclose(
+    baseline_hit_pos[0, 0, 2],
+    torch.tensor(0.0, device=device),
+    atol=0.1,
+  ), f"Baseline Z hit should be ~0, got {baseline_hit_pos[0, 0, 2]}"
+
+  # Pitch 90 degrees around Y-axis. Body X-axis now points straight
+  # down (singularity).
+  angle = math.pi / 2
+  quat = [math.cos(angle / 2), 0, math.sin(angle / 2), 0]  # w, x, y, z
+  sim.data.qpos[0, 3:7] = torch.tensor(quat, device=device)
+  sim.step()
+  scene.update(dt=sim.cfg.mujoco.timestep)
+  sim.sense()
+
+  singularity_hit_pos = sensor.data.hit_pos_w
+
+  # With yaw alignment, hit position should match baseline regardless
+  # of pitch. The ray should still go diagonally and hit at (2, 0, 0).
+  assert torch.allclose(singularity_hit_pos, baseline_hit_pos, atol=0.1), (
+    f"Yaw alignment failed at 90 degree pitch singularity.\n"
+    f"Baseline hit_pos: {baseline_hit_pos}\n"
+    f"Singularity hit_pos: {singularity_hit_pos}"
+  )
+
+
+class _FakeEnv:
+  """Minimal env-like object for testing observation functions."""
+
+  def __init__(self, scene):
+    self.scene = scene
+
+
+def test_height_scan_hits(robot_with_floor_xml, device):
+  """height_scan returns correct heights for hits."""
+
+  raycast_cfg = RayCastSensorCfg(
+    name="terrain_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(
+      size=(0.3, 0.3),
+      resolution=0.15,
+      direction=(0.0, 0.0, -1.0),
+    ),
+    max_distance=10.0,
+  )
+
+  scene, sim = make_scene_and_sim(
+    device, robot_with_floor_xml, sensors=(raycast_cfg,), num_envs=2
+  )
+
+  sim.step()
+  sim.sense()
+
+  env = _FakeEnv(scene)
+  heights = height_scan(env, "terrain_scan")  # type: ignore[invalid-argument-type]
+
+  sensor = scene["terrain_scan"]
+  # Shape: [num_envs, num_rays].
+  assert heights.shape == (2, sensor.num_rays)
+  # Body at z=2, floor at z=0 → height ≈ 2.0.
+  assert torch.allclose(heights, torch.full_like(heights, 2.0), atol=0.1)
+
+
+def test_height_scan_misses(device):
+  """height_scan reports max_distance for rays that miss (no ground)."""
+
+  no_floor_xml = """
+    <mujoco>
+      <worldbody>
+        <body name="base" pos="0 0 2">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="5.0"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  raycast_cfg = RayCastSensorCfg(
+    name="terrain_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(
+      size=(0.2, 0.2),
+      resolution=0.1,
+      direction=(0.0, 0.0, -1.0),
+    ),
+    max_distance=10.0,
+    exclude_parent_body=True,
+  )
+
+  scene, sim = make_scene_and_sim(device, no_floor_xml, sensors=(raycast_cfg,))
+
+  sim.step()
+  sim.sense()
+
+  env = _FakeEnv(scene)
+  heights = height_scan(env, "terrain_scan")  # type: ignore[invalid-argument-type]
+
+  # Misses default to sensor max_distance.
+  assert torch.allclose(
+    heights, torch.full_like(heights, raycast_cfg.max_distance), atol=1e-5
+  )
+
+
+# ============================================================================
+# Multi-Frame Tests
+# ============================================================================
+
+MULTI_SITE_XML = """
+  <mujoco>
+    <worldbody>
+      <geom name="floor" type="plane" size="10 10 0.1" pos="0 0 0"/>
+      <body name="base" pos="0 0 3">
+        <freejoint name="free_joint"/>
+        <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="5.0"/>
+        <site name="site_top" pos="0 0 0.5"/>
+        <site name="site_mid" pos="0 0 0"/>
+        <site name="site_bot" pos="0 0 -0.5"/>
+      </body>
+    </worldbody>
+  </mujoco>
+"""
+
+
+def test_multi_frame_shapes(device):
+  """Multi-frame sensor produces correct output shapes."""
+  cfg = RayCastSensorCfg(
+    name="multi",
+    frame=(
+      ObjRef(type="site", name="site_top", entity="robot"),
+      ObjRef(type="site", name="site_mid", entity="robot"),
+      ObjRef(type="site", name="site_bot", entity="robot"),
+    ),
+    pattern=GridPatternCfg(size=(0.0, 0.0), resolution=0.1),
+    max_distance=10.0,
+  )
+
+  scene, sim = make_scene_and_sim(device, MULTI_SITE_XML, (cfg,), num_envs=2)
+  sim.step()
+  sim.sense()
+
+  sensor = scene["multi"]
+  data = sensor.data
+
+  assert sensor.num_frames == 3
+  assert sensor.num_rays_per_frame == 1
+  assert sensor.num_rays == 3
+
+  assert data.distances.shape == (2, 3)
+  assert data.frame_pos_w.shape == (2, 3, 3)
+  assert data.frame_quat_w.shape == (2, 3, 4)
+  # Backward compat: pos_w/quat_w equal first frame.
+  assert data.pos_w.shape == (2, 3)
+  assert data.quat_w.shape == (2, 4)
+  assert torch.allclose(data.pos_w, data.frame_pos_w[:, 0])
+  assert torch.allclose(data.quat_w, data.frame_quat_w[:, 0])
+
+
+def test_multi_frame_heights(device):
+  """Sites at different Z offsets produce proportional distances."""
+  cfg = RayCastSensorCfg(
+    name="multi",
+    frame=(
+      ObjRef(type="site", name="site_top", entity="robot"),
+      ObjRef(type="site", name="site_mid", entity="robot"),
+      ObjRef(type="site", name="site_bot", entity="robot"),
+    ),
+    pattern=GridPatternCfg(size=(0.0, 0.0), resolution=0.1),
+    max_distance=10.0,
+  )
+
+  scene, sim = make_scene_and_sim(device, MULTI_SITE_XML, (cfg,))
+  sim.step()
+  sim.sense()
+
+  distances = scene["multi"].data.distances[0]
+  # site_top at z=3.5, site_mid at z=3, site_bot at z=2.5.
+  assert distances[0].item() == pytest.approx(3.5, abs=0.1)
+  assert distances[1].item() == pytest.approx(3.0, abs=0.1)
+  assert distances[2].item() == pytest.approx(2.5, abs=0.1)
+
+
+def test_multi_frame_body_exclusion(device):
+  """Each frame excludes only its own parent body, not others.
+
+  body_a has a platform geom directly below site_b. Frame B's rays
+  should skip body_b's own geom but HIT body_a's platform. Frame A's
+  rays should skip body_a and hit the floor.
+  """
+  body_a_xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1" pos="0 0 0"/>
+        <body name="body_a" pos="0 0 1">
+          <freejoint name="free_a"/>
+          <geom name="geom_a" type="box" size="2 2 0.1" mass="5.0"/>
+          <site name="site_a" pos="0 0 0"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+  body_b_xml = """
+    <mujoco>
+      <worldbody>
+        <body name="body_b" pos="0 0 3">
+          <freejoint name="free_b"/>
+          <geom name="geom_b" type="box" size="0.5 0.5 0.5" mass="5.0"/>
+          <site name="site_b" pos="0 0 0"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  cfg = RayCastSensorCfg(
+    name="multi",
+    frame=(
+      ObjRef(type="site", name="site_a", entity="body_a"),
+      ObjRef(type="site", name="site_b", entity="body_b"),
+    ),
+    pattern=GridPatternCfg(size=(0.0, 0.0), resolution=0.1),
+    max_distance=10.0,
+    exclude_parent_body=True,
+  )
+
+  scene, sim = make_scene_and_sim(
+    device, {"body_a": body_a_xml, "body_b": body_b_xml}, (cfg,)
+  )
+  sim.step()
+  sim.sense()
+
+  distances = scene["multi"].data.distances[0]
+  # Frame A (site_a at z=1): excludes body_a, hits floor at z=0 -> dist ~1.0.
+  assert distances[0].item() == pytest.approx(1.0, abs=0.15)
+  # Frame B (site_b at z=3): excludes body_b, hits body_a's platform
+  # at z=1.1 -> dist ~1.9.
+  assert distances[1].item() == pytest.approx(1.9, abs=0.15)
+
+
+def test_multi_frame_height_scan(device):
+  """height_scan works correctly with multi-frame sensors."""
+  cfg = RayCastSensorCfg(
+    name="multi",
+    frame=(
+      ObjRef(type="site", name="site_top", entity="robot"),
+      ObjRef(type="site", name="site_mid", entity="robot"),
+      ObjRef(type="site", name="site_bot", entity="robot"),
+    ),
+    pattern=GridPatternCfg(size=(0.0, 0.0), resolution=0.1),
+    max_distance=10.0,
+  )
+
+  scene, sim = make_scene_and_sim(device, MULTI_SITE_XML, (cfg,), num_envs=2)
+  sim.step()
+  sim.sense()
+
+  env = _FakeEnv(scene)
+  heights = height_scan(env, "multi")  # type: ignore[invalid-argument-type]
+
+  assert heights.shape == (2, 3)
+  # Each frame's height = frame_z - hit_z.
+  # site_top at z=3.5, site_mid at z=3, site_bot at z=2.5; floor at z=0.
+  assert heights[0, 0].item() == pytest.approx(3.5, abs=0.1)
+  assert heights[0, 1].item() == pytest.approx(3.0, abs=0.1)
+  assert heights[0, 2].item() == pytest.approx(2.5, abs=0.1)
+
+
+# ============================================================================
+# Ring Pattern Tests
+# ============================================================================
+
+
+def test_ring_pattern_num_rays(device):
+  """Ring with 8 samples + center = 9 rays."""
+  cfg = RayCastSensorCfg(
+    name="ring",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=RingPatternCfg.single_ring(radius=0.1, num_samples=8, include_center=True),
+  )
+
+  simple_xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1"/>
+        <body name="base" pos="0 0 1">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.1"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  scene, sim = make_scene_and_sim(device, simple_xml, (cfg,))
+  sensor = scene["ring"]
+  assert sensor.num_rays == 9
+  assert sensor.num_rays_per_frame == 9
+
+
+def test_ring_pattern_concentric(device):
+  """Concentric rings: 1 center + 4 + 6 + 8 = 19 rays."""
+  cfg = RayCastSensorCfg(
+    name="ring",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=RingPatternCfg(
+      rings=(
+        RingPatternCfg.Ring(radius=0.05, num_samples=4),
+        RingPatternCfg.Ring(radius=0.10, num_samples=6),
+        RingPatternCfg.Ring(radius=0.20, num_samples=8),
+      ),
+      include_center=True,
+    ),
+  )
+
+  simple_xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1"/>
+        <body name="base" pos="0 0 1">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.1"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  scene, sim = make_scene_and_sim(device, simple_xml, (cfg,))
+  sensor = scene["ring"]
+  assert sensor.num_rays == 19
+
+
+def test_ring_pattern_hits_floor(device):
+  """Ring pattern hits floor and ring offsets lie on a circle."""
+  radius = 0.1
+  cfg = RayCastSensorCfg(
+    name="ring",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=RingPatternCfg.single_ring(
+      radius=radius, num_samples=4, include_center=True
+    ),
+    max_distance=10.0,
+  )
+
+  simple_xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1"/>
+        <body name="base" pos="0 0 2">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.05"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  scene, sim = make_scene_and_sim(device, simple_xml, (cfg,))
+  sim.step()
+  sim.sense()
+
+  data = scene["ring"].data
+  # All 5 rays (1 center + 4 ring) should hit the floor.
+  assert torch.all(data.distances >= 0)
+  assert torch.allclose(data.distances, torch.full_like(data.distances, 2.0), atol=0.1)
+
+  # Verify ring geometry: non-center hits should lie on a circle of
+  # the given radius around the body's XY position.
+  hit_xy = data.hit_pos_w[0, :, :2]  # [5, 2]
+  body_xy = data.pos_w[0, :2]  # [2]
+  dists_from_center = (hit_xy - body_xy).norm(dim=1)
+  # Center ray (index 0) should be at ~0 offset.
+  assert dists_from_center[0].item() == pytest.approx(0.0, abs=0.02)
+  # Ring rays (indices 1-4) should be at ~radius offset.
+  for i in range(1, 5):
+    assert dists_from_center[i].item() == pytest.approx(radius, abs=0.02)
+
+
+def test_ring_pattern_no_center(device):
+  """Ring with include_center=False omits the center ray."""
+  cfg = RayCastSensorCfg(
+    name="ring",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=RingPatternCfg.single_ring(radius=0.1, num_samples=4, include_center=False),
+  )
+  simple_xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="10 10 0.1"/>
+        <body name="base" pos="0 0 1">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="sphere" size="0.1"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+  scene, sim = make_scene_and_sim(device, simple_xml, (cfg,))
+  assert scene["ring"].num_rays == 4
+
+
+def test_multi_frame_multiple_rays_per_frame(device):
+  """Multi-frame with grid pattern: verifies reshape ordering."""
+  cfg = RayCastSensorCfg(
+    name="multi",
+    frame=(
+      ObjRef(type="site", name="site_top", entity="robot"),
+      ObjRef(type="site", name="site_bot", entity="robot"),
+    ),
+    pattern=GridPatternCfg(size=(0.2, 0.2), resolution=0.1),
+    max_distance=10.0,
+  )
+
+  scene, sim = make_scene_and_sim(device, MULTI_SITE_XML, (cfg,))
+  sim.step()
+  sim.sense()
+
+  sensor = scene["multi"]
+  N = sensor.num_rays_per_frame
+  assert N == 9  # 3x3 grid
+  assert sensor.num_rays == 18  # 2 frames * 9
+
+  data = sensor.data
+  # First frame (site_top, z=3.5) rays should all be ~3.5.
+  top_dists = data.distances[0, :N]
+  assert torch.allclose(top_dists, torch.full_like(top_dists, 3.5), atol=0.1)
+  # Second frame (site_bot, z=2.5) rays should all be ~2.5.
+  bot_dists = data.distances[0, N:]
+  assert torch.allclose(bot_dists, torch.full_like(bot_dists, 2.5), atol=0.1)
+
+  # height_scan should also produce correct per-frame heights.
+  env = _FakeEnv(scene)
+  heights = height_scan(env, "multi")  # type: ignore[invalid-argument-type]
+  assert heights.shape == (1, 18)
+  top_heights = heights[0, :N]
+  bot_heights = heights[0, N:]
+  assert torch.allclose(top_heights, torch.full_like(top_heights, 3.5), atol=0.1)
+  assert torch.allclose(bot_heights, torch.full_like(bot_heights, 2.5), atol=0.1)
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="Likely bug on CPU MjWarp")
+def test_site_origin_is_physical_with_world_alignment(device):
+  """ray_alignment only controls direction, not origin position.
+
+  When a calf body pitches, the foot site swings to its physical
+  position (site_xpos). Rays still point -Z (world-aligned), giving
+  the correct distance from the actual foot to the ground.
+  """
+  xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="floor" type="plane" size="50 50 0.1" pos="0 0 0"/>
+        <body name="calf" pos="0 0 1">
+          <freejoint name="free_joint"/>
+          <geom name="calf_geom" type="sphere" size="0.05" mass="1.0"/>
+          <site name="foot" pos="0 0 -0.5"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+
+  cfg = RayCastSensorCfg(
+    name="scan",
+    frame=ObjRef(type="site", name="foot", entity="robot"),
+    pattern=GridPatternCfg(size=(0.0, 0.0), resolution=0.1),
+    ray_alignment="world",
+    max_distance=5.0,
+  )
+
+  sim_cfg = SimulationCfg(mujoco=MujocoCfg(gravity=(0, 0, 0)), njmax=20)
+  scene, sim = make_scene_and_sim(device, xml, (cfg,), sim_cfg=sim_cfg)
+
+  # Baseline: body upright, site at z=0.5.
+  sim.step()
+  scene.update(dt=sim.cfg.mujoco.timestep)
+  sim.sense()
+  data = scene["scan"].data
+  assert data.pos_w[0, 2].item() == pytest.approx(0.5, abs=0.05)
+  assert data.distances[0, 0].item() == pytest.approx(0.5, abs=0.05)
+
+  # Pitch calf 90 degrees. Site swings to (0, -0.5, 1.0).
+  # Ray points -Z (world), distance to floor = 1.0.
+  angle = math.pi / 2
+  quat = [math.cos(angle / 2), math.sin(angle / 2), 0, 0]
+  sim.data.qpos[0, 3:7] = torch.tensor(quat, device=device)
+  sim.step()
+  scene.update(dt=sim.cfg.mujoco.timestep)
+  sim.sense()
+  data = scene["scan"].data
+
+  assert data.pos_w[0, 2].item() == pytest.approx(1.0, abs=0.1)
+  assert data.distances[0, 0].item() == pytest.approx(1.0, abs=0.1)
+
+
+@pytest.mark.parametrize("groups", [(6,), (-1,), (0, 7)])
+def test_include_geom_groups_out_of_range_raises(groups):
+  """Out-of-range geom groups should raise rather than silently exclude."""
+  with pytest.raises(ValueError, match="include_geom_groups must be in"):
+    _geom_groups_to_vec6(groups)
diff --git a/tests/test_recorder_manager.py b/tests/test_recorder_manager.py
new file mode 100644
index 0000000..5ae1af4
--- /dev/null
+++ b/tests/test_recorder_manager.py
@@ -0,0 +1,502 @@
+"""Tests for the recorder manager."""
+
+from unittest.mock import Mock
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.actuator import BuiltinPositionActuatorCfg
+from mjlab.entity import EntityArticulationInfoCfg, EntityCfg
+from mjlab.envs import ManagerBasedRlEnv, ManagerBasedRlEnvCfg, mdp
+from mjlab.managers.observation_manager import ObservationGroupCfg, ObservationTermCfg
+from mjlab.managers.recorder_manager import (
+  NullRecorderManager,
+  RecorderManager,
+  RecorderTerm,
+  RecorderTermCfg,
+)
+from mjlab.managers.termination_manager import TerminationTermCfg
+from mjlab.scene import SceneCfg
+from mjlab.sim import MujocoCfg, SimulationCfg
+from mjlab.terrains import TerrainEntityCfg
+
+
+class _CountingRecorder(RecorderTerm):
+  """Records calls to each lifecycle method for inspection."""
+
+  def __init__(self, cfg, env):
+    super().__init__(cfg, env)
+    self.pre_reset_calls: list[torch.Tensor] = []
+    self.post_reset_calls: list[torch.Tensor] = []
+    self.post_step_count = 0
+    self.closed = False
+
+  def record_pre_reset(self, env_ids: torch.Tensor) -> None:
+    self.pre_reset_calls.append(env_ids.clone())
+
+  def record_post_reset(self, env_ids: torch.Tensor) -> None:
+    self.post_reset_calls.append(env_ids.clone())
+
+  def record_post_step(self) -> None:
+    self.post_step_count += 1
+
+  def close(self) -> None:
+    self.closed = True
+
+
+@pytest.fixture
+def mock_env() -> Mock:
+  env = Mock()
+  env.num_envs = 4
+  env.device = "cpu"
+  return env
+
+
+@pytest.fixture
+def manager_and_term(mock_env: Mock) -> tuple[RecorderManager, _CountingRecorder]:
+  cfg = {"recorder": RecorderTermCfg(func=_CountingRecorder, params={})}
+  manager = RecorderManager(cfg, mock_env)
+  term = manager.get_term("recorder")
+  assert isinstance(term, _CountingRecorder)
+  return manager, term
+
+
+# Lifecycle semantics.
+
+
+def test_terminal_action_available_at_record_pre_reset(mock_env: Mock) -> None:
+  """record_pre_reset fires before _reset_idx, so action_manager.action is intact.
+
+  In step(), the sequence is:
+    record_pre_reset(reset_env_ids)   <- action still set
+    _reset_idx(reset_env_ids)         <- zeroes action_manager.action
+    ...
+    record_post_step()                <- action is now 0 for reset envs
+
+  A recorder that wants the terminal action MUST capture it at record_pre_reset.
+  """
+  seen: dict[str, torch.Tensor] = {}
+
+  class ActionCapture(RecorderTerm):
+    def record_pre_reset(self, env_ids: torch.Tensor) -> None:
+      seen["pre_reset_action"] = self._env.action_manager.action[env_ids].clone()
+
+    def record_post_step(self) -> None:
+      seen["post_step_action"] = self._env.action_manager.action.clone()
+
+  mock_env.action_manager = Mock()
+  mock_env.action_manager.action = torch.tensor(
+    [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]]
+  )
+
+  cfg = {"r": RecorderTermCfg(func=ActionCapture, params={})}
+  manager = RecorderManager(cfg, mock_env)
+
+  reset_env_ids = torch.tensor([0, 2])
+
+  # Simulate step(): record_pre_reset fires before _reset_idx zeros actions.
+  manager.record_pre_reset(reset_env_ids)
+  assert torch.equal(
+    seen["pre_reset_action"],
+    torch.tensor([[1.0, 2.0], [5.0, 6.0]]),
+  ), "Terminal action must be intact at record_pre_reset"
+
+  # Simulate _reset_idx: zeros action for reset envs.
+  mock_env.action_manager.action[reset_env_ids] = 0.0
+
+  manager.record_post_step()
+  assert torch.all(seen["post_step_action"][reset_env_ids] == 0.0), (
+    "Action is zeroed for reset envs at record_post_step; use record_pre_reset"
+    " to capture terminal actions"
+  )
+  # Non-reset envs retain their action.
+  non_reset = torch.tensor([1, 3])
+  assert torch.equal(
+    seen["post_step_action"][non_reset],
+    torch.tensor([[3.0, 4.0], [7.0, 8.0]]),
+  )
+
+
+def test_record_pre_reset_obs_buf_is_previous_step(mock_env: Mock) -> None:
+  """obs_buf at record_pre_reset is the previous step's observation, not the post-action
+  terminal state. It is the input obs the agent used to pick the terminal action.
+  """
+  seen: dict[str, torch.Tensor] = {}
+
+  # Use a plain tensor for obs_buf to avoid dict-subscript complexity in the type
+  # checker. The point of this test is lifecycle timing, not data structure.
+  class ObsCapture(RecorderTerm):
+    def record_pre_reset(self, env_ids: torch.Tensor) -> None:
+      obs: torch.Tensor = self._env.obs_buf  # type: ignore[assignment]
+      seen["pre_reset_obs"] = obs[env_ids].clone()
+
+    def record_post_step(self) -> None:
+      obs: torch.Tensor = self._env.obs_buf  # type: ignore[assignment]
+      seen["post_step_obs"] = obs.clone()
+
+  prev_obs = torch.arange(8, dtype=torch.float).reshape(4, 2)
+  mock_env.obs_buf = prev_obs.clone()
+
+  cfg = {"r": RecorderTermCfg(func=ObsCapture, params={})}
+  manager = RecorderManager(cfg, mock_env)
+
+  reset_env_ids = torch.tensor([1])
+  manager.record_pre_reset(reset_env_ids)
+  # obs_buf at pre_reset is unchanged from the previous step.
+  assert torch.equal(seen["pre_reset_obs"], prev_obs[reset_env_ids])
+
+  # Simulate _reset_idx + obs recompute: reset env gets new initial obs.
+  mock_env.obs_buf[reset_env_ids] = torch.zeros(1, 2)
+  manager.record_post_step()
+  assert torch.all(seen["post_step_obs"][reset_env_ids] == 0.0), (
+    "After reset, obs_buf for the reset env holds the new-episode initial obs"
+  )
+
+
+def test_record_post_reset_fires_after_obs_are_fresh(mock_env: Mock) -> None:
+  """record_post_reset is called after obs are computed, so obs_buf already holds the
+  new-episode initial observation for the reset environments.
+  """
+  seen: dict[str, torch.Tensor] = {}
+
+  class ResetObsCapture(RecorderTerm):
+    def record_post_reset(self, env_ids: torch.Tensor) -> None:
+      obs: torch.Tensor = self._env.obs_buf  # type: ignore[assignment]
+      seen["obs"] = obs[env_ids].clone()
+
+  reset_obs = torch.ones(4, 2) * 99.0
+  mock_env.obs_buf = reset_obs
+
+  cfg = {"r": RecorderTermCfg(func=ResetObsCapture, params={})}
+  manager = RecorderManager(cfg, mock_env)
+
+  env_ids = torch.tensor([0, 3])
+  manager.record_post_reset(env_ids)
+  assert torch.equal(seen["obs"], reset_obs[env_ids])
+
+
+def test_record_pre_reset_before_record_post_step_in_step(mock_env: Mock) -> None:
+  """record_pre_reset fires before record_post_step within a single step."""
+  call_log: list[str] = []
+
+  class OrderRecorder(RecorderTerm):
+    def record_pre_reset(self, env_ids: torch.Tensor) -> None:
+      call_log.append("pre_reset")
+
+    def record_post_step(self) -> None:
+      call_log.append("post_step")
+
+  cfg = {"r": RecorderTermCfg(func=OrderRecorder, params={})}
+  manager = RecorderManager(cfg, mock_env)
+
+  manager.record_pre_reset(torch.tensor([0]))
+  manager.record_post_step()
+
+  assert call_log == ["pre_reset", "post_step"]
+
+
+# Manager dispatch.
+
+
+def test_record_post_step_called_each_step(
+  manager_and_term: tuple[RecorderManager, _CountingRecorder],
+) -> None:
+  manager, term = manager_and_term
+  for _ in range(5):
+    manager.record_post_step()
+  assert term.post_step_count == 5
+
+
+def test_record_pre_reset_passes_env_ids(
+  manager_and_term: tuple[RecorderManager, _CountingRecorder],
+) -> None:
+  manager, term = manager_and_term
+  env_ids = torch.tensor([0, 2])
+  manager.record_pre_reset(env_ids)
+  assert len(term.pre_reset_calls) == 1
+  assert torch.equal(term.pre_reset_calls[0], env_ids)
+
+
+def test_record_post_reset_passes_env_ids(
+  manager_and_term: tuple[RecorderManager, _CountingRecorder],
+) -> None:
+  manager, term = manager_and_term
+  env_ids = torch.tensor([1, 3])
+  manager.record_post_reset(env_ids)
+  assert len(term.post_reset_calls) == 1
+  assert torch.equal(term.post_reset_calls[0], env_ids)
+
+
+def test_close_propagates_to_all_terms(mock_env: Mock) -> None:
+  cfg = {
+    "a": RecorderTermCfg(func=_CountingRecorder, params={}),
+    "b": RecorderTermCfg(func=_CountingRecorder, params={}),
+  }
+  manager = RecorderManager(cfg, mock_env)
+  term_a = manager.get_term("a")
+  term_b = manager.get_term("b")
+  assert isinstance(term_a, _CountingRecorder)
+  assert isinstance(term_b, _CountingRecorder)
+
+  manager.close()
+  assert term_a.closed
+  assert term_b.closed
+
+
+def test_terms_called_in_registration_order(mock_env: Mock) -> None:
+  call_log: list[str] = []
+
+  class NamedRecorder(RecorderTerm):
+    def __init__(self, cfg, env):
+      super().__init__(cfg, env)
+      self._name: str = cfg.params["name"]
+
+    def record_post_step(self) -> None:
+      call_log.append(self._name)
+
+  cfg = {
+    "first": RecorderTermCfg(func=NamedRecorder, params={"name": "first"}),
+    "second": RecorderTermCfg(func=NamedRecorder, params={"name": "second"}),
+    "third": RecorderTermCfg(func=NamedRecorder, params={"name": "third"}),
+  }
+  manager = RecorderManager(cfg, mock_env)
+  manager.record_post_step()
+  assert call_log == ["first", "second", "third"]
+
+
+def test_multiple_terms_have_independent_state(mock_env: Mock) -> None:
+  cfg = {
+    "a": RecorderTermCfg(func=_CountingRecorder, params={}),
+    "b": RecorderTermCfg(func=_CountingRecorder, params={}),
+  }
+  manager = RecorderManager(cfg, mock_env)
+  term_a = manager.get_term("a")
+  term_b = manager.get_term("b")
+  assert isinstance(term_a, _CountingRecorder)
+  assert isinstance(term_b, _CountingRecorder)
+
+  manager.record_post_step()
+  manager.record_post_step()
+  manager.record_pre_reset(torch.tensor([0]))
+
+  assert term_a.post_step_count == 2
+  assert term_b.post_step_count == 2
+  assert len(term_a.pre_reset_calls) == 1
+  assert len(term_b.pre_reset_calls) == 1
+
+
+def test_active_terms_matches_registration_order(mock_env: Mock) -> None:
+  cfg = {
+    "first": RecorderTermCfg(func=_CountingRecorder, params={}),
+    "second": RecorderTermCfg(func=_CountingRecorder, params={}),
+  }
+  manager = RecorderManager(cfg, mock_env)
+  assert manager.active_terms == ["first", "second"]
+
+
+def test_none_terms_skipped(mock_env: Mock) -> None:
+  cfg: dict[str, RecorderTermCfg | None] = {
+    "valid": RecorderTermCfg(func=_CountingRecorder, params={}),
+    "skipped": None,
+  }
+  manager = RecorderManager(cfg, mock_env)  # type: ignore[arg-type]
+  assert manager.active_terms == ["valid"]
+  assert len(manager._terms) == 1
+
+
+def test_function_based_term_raises(mock_env: Mock) -> None:
+  cfg = {"bad": RecorderTermCfg(func=lambda env: None, params={})}
+  with pytest.raises(TypeError, match="RecorderTerm subclass"):
+    RecorderManager(cfg, mock_env)
+
+
+def test_cfg_params_accessible_on_term(mock_env: Mock) -> None:
+  cfg = {"t": RecorderTermCfg(func=_CountingRecorder, params={"path": "/tmp/out.csv"})}
+  manager = RecorderManager(cfg, mock_env)
+  term = manager.get_term("t")
+  assert isinstance(term, _CountingRecorder)
+  assert term.cfg.params["path"] == "/tmp/out.csv"
+
+
+def test_deepcopy_protects_original_cfg(mock_env: Mock) -> None:
+  """Creating a manager must not mutate the caller's cfg dict.
+
+  _resolve_common_term_cfg replaces cfg.func with the instantiated object in-place on
+  the internal copy. Without deepcopy the caller's cfg would be silently corrupted,
+  breaking any second use.
+  """
+  original_cfg = {"t": RecorderTermCfg(func=_CountingRecorder, params={})}
+  RecorderManager(original_cfg, mock_env)
+  assert original_cfg["t"].func is _CountingRecorder
+
+
+def test_null_recorder_manager_no_ops() -> None:
+  manager = NullRecorderManager()
+  env_ids = torch.tensor([0, 1])
+  manager.record_pre_reset(env_ids)
+  manager.record_post_reset(env_ids)
+  manager.record_post_step()
+  manager.close()
+  assert manager.active_terms == []
+
+
+# Public term lookup.
+
+
+def test_get_term_returns_registered_instance(mock_env: Mock) -> None:
+  """get_term returns the live term the manager dispatches to, not a copy."""
+  cfg = {"recorder": RecorderTermCfg(func=_CountingRecorder, params={})}
+  manager = RecorderManager(cfg, mock_env)
+  term = manager.get_term("recorder")
+  assert isinstance(term, _CountingRecorder)
+  manager.record_post_step()
+  # The instance returned by get_term is the same one the manager dispatches to.
+  assert term.post_step_count == 1
+
+
+def test_get_term_missing_raises(mock_env: Mock) -> None:
+  """get_term raises KeyError when the requested term name is not registered."""
+  cfg = {"recorder": RecorderTermCfg(func=_CountingRecorder, params={})}
+  manager = RecorderManager(cfg, mock_env)
+  with pytest.raises(KeyError, match="missing"):
+    manager.get_term("missing")
+
+
+def test_contains_for_recorder_manager(mock_env: Mock) -> None:
+  """`in` reflects whether a term name is registered on the manager."""
+  cfg = {"recorder": RecorderTermCfg(func=_CountingRecorder, params={})}
+  manager = RecorderManager(cfg, mock_env)
+  assert "recorder" in manager
+  assert "other" not in manager
+
+
+def test_contains_and_get_term_for_null_manager() -> None:
+  """NullRecorderManager has no terms: `in` is always False and get_term raises."""
+  manager = NullRecorderManager()
+  assert "anything" not in manager
+  with pytest.raises(KeyError):
+    manager.get_term("anything")
+
+
+def test_base_term_all_hooks_are_no_ops(mock_env: Mock) -> None:
+  """Base RecorderTerm hooks do nothing; __call__ raises NotImplementedError."""
+
+  class MinimalRecorder(RecorderTerm):
+    pass
+
+  term = MinimalRecorder(
+    cfg=RecorderTermCfg(func=MinimalRecorder, params={}), env=mock_env
+  )
+  env_ids = torch.tensor([0])
+  term.record_pre_reset(env_ids)
+  term.record_post_reset(env_ids)
+  term.record_post_step()
+  term.close()
+
+  with pytest.raises(NotImplementedError):
+    term()
+
+
+# Integration: real ManagerBasedRlEnv.
+
+
+_SLIDING_MASS_XML = """
+<mujoco>
+  <option timestep="0.002"/>
+  <worldbody>
+    <body name="mass" pos="0 0 0">
+      <joint name="slide" type="slide" axis="1 0 0" range="-1 1" limited="true"/>
+      <geom name="mass_geom" type="sphere" size="0.1" mass="1.0"/>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+
+def _make_env_cfg(recorders: dict | None = None) -> ManagerBasedRlEnvCfg:
+  """One-step episode (time_out fires after a single step)."""
+  timestep = 0.002
+  return ManagerBasedRlEnvCfg(
+    scene=SceneCfg(
+      terrain=TerrainEntityCfg(terrain_type="plane"),
+      num_envs=2,
+      extent=1.0,
+      entities={
+        "robot": EntityCfg(
+          spec_fn=lambda: mujoco.MjSpec.from_string(_SLIDING_MASS_XML),
+          articulation=EntityArticulationInfoCfg(
+            actuators=(
+              BuiltinPositionActuatorCfg(
+                target_names_expr=(".*",), stiffness=100.0, damping=10.0
+              ),
+            )
+          ),
+        )
+      },
+    ),
+    observations={
+      "actor": ObservationGroupCfg(
+        terms={"obs": ObservationTermCfg(func=mdp.joint_pos_rel)}
+      )
+    },
+    actions={
+      "joint_pos": mdp.JointPositionActionCfg(
+        entity_name="robot", actuator_names=(".*",), scale=1.0
+      )
+    },
+    terminations={"time_out": TerminationTermCfg(func=mdp.time_out, time_out=True)},
+    events={},
+    sim=SimulationCfg(mujoco=MujocoCfg(timestep=timestep, iterations=1)),
+    decimation=1,
+    episode_length_s=timestep,  # terminates every env after exactly one step
+    recorders=recorders or {},
+  )
+
+
+@pytest.fixture(scope="module")
+def device() -> str:
+  return get_test_device()
+
+
+def test_integration_terminal_action_available_at_record_pre_reset(device: str) -> None:
+  """In a real env.step(), record_pre_reset fires before _reset_idx zeroes
+  action_manager.action for reset envs. This verifies the hook ordering described in
+  the docstring is enforced by the actual step() implementation.
+  """
+  seen: dict[str, torch.Tensor] = {}
+
+  class HookOrderRecorder(RecorderTerm):
+    def record_pre_reset(self, env_ids: torch.Tensor) -> None:
+      # Action must still be non-zero; _reset_idx has not run yet.
+      seen["pre_reset_action"] = self._env.action_manager.action[env_ids].clone()
+
+    def record_post_step(self) -> None:
+      seen["post_step_action"] = self._env.action_manager.action.clone()
+      seen["reset_buf"] = self._env.reset_buf.clone()
+
+  cfg = _make_env_cfg(
+    recorders={"r": RecorderTermCfg(func=HookOrderRecorder, params={})}
+  )
+  env = ManagerBasedRlEnv(cfg=cfg, device=device)
+  env.reset()
+
+  action = torch.ones(2, 1, device=device) * 0.5
+  env.step(action)
+
+  # With episode_length_s = one timestep, both envs time out on the first step.
+  assert seen["reset_buf"].all(), "Both envs should have reset after one step"
+
+  # Terminal action must have been captured intact at record_pre_reset.
+  assert seen["pre_reset_action"].shape == (2, 1)
+  assert torch.allclose(seen["pre_reset_action"], action), (
+    "record_pre_reset must see the applied action before _reset_idx zeroes it"
+  )
+
+  # By record_post_step the action is zeroed for all reset envs.
+  assert torch.all(seen["post_step_action"] == 0.0), (
+    "action_manager.action is zeroed for reset envs by the time record_post_step runs"
+  )
+
+  env.close()
diff --git a/tests/test_reward_bar_panel.py b/tests/test_reward_bar_panel.py
new file mode 100644
index 0000000..32ca3fd
--- /dev/null
+++ b/tests/test_reward_bar_panel.py
@@ -0,0 +1,34 @@
+"""Tests for the Viser reward bar panel term cap."""
+
+from unittest.mock import Mock
+
+import pytest
+
+from mjlab.viewer.viser.reward_bar_panel import RewardBarPanel
+
+
+def _term_names(n: int) -> list[str]:
+  return [f"term_{i}" for i in range(n)]
+
+
+def test_warns_and_truncates_over_cap():
+  """More terms than the cap warns and keeps only the first ``max_terms``."""
+  server = Mock()
+  with pytest.warns(UserWarning, match="exceed max_terms"):
+    panel = RewardBarPanel(server, _term_names(21), update_dt=1 / 30, max_terms=20)
+  assert panel._term_names == _term_names(21)[:20]
+
+
+def test_no_warning_at_or_below_cap(recwarn):
+  """At or below the cap, all terms are kept and no truncation warning fires."""
+  server = Mock()
+  panel = RewardBarPanel(server, _term_names(20), update_dt=1 / 30, max_terms=20)
+  assert panel._term_names == _term_names(20)
+  assert not [w for w in recwarn if "exceed max_terms" in str(w.message)]
+
+
+def test_raised_cap_shows_all_terms():
+  """Raising ``max_terms`` (the fix for #1079) surfaces the overflow terms."""
+  server = Mock()
+  panel = RewardBarPanel(server, _term_names(24), update_dt=1 / 30, max_terms=32)
+  assert panel._term_names == _term_names(24)
diff --git a/tests/test_rewards.py b/tests/test_rewards.py
new file mode 100644
index 0000000..e218bb1
--- /dev/null
+++ b/tests/test_rewards.py
@@ -0,0 +1,363 @@
+"""Tests for reward manager functionality."""
+
+from unittest.mock import Mock
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.actuator import BuiltinPositionActuatorCfg
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.envs.mdp.rewards import electrical_power_cost, joint_torques_l2
+from mjlab.managers.reward_manager import RewardManager, RewardTermCfg
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+PARTIALLY_ACTUATED_ROBOT_XML = """
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 0.5">
+      <geom name="base_geom" type="cylinder" size="0.1 0.05" mass="1.0"/>
+      <body name="link1" pos="0 0 0.1">
+        <joint name="actuated_joint1" type="hinge" axis="0 0 1" range="-3.14 3.14"/>
+        <geom name="link1_geom" type="box" size="0.05 0.05 0.2" mass="0.5"/>
+        <body name="link2" pos="0 0 0.4">
+          <joint name="passive_joint" type="hinge" axis="0 1 0" range="-1.57 1.57"/>
+          <geom name="link2_geom" type="box" size="0.05 0.05 0.15" mass="0.3"/>
+          <body name="link3" pos="0 0 0.3">
+            <joint name="actuated_joint2" type="hinge" axis="1 0 0" range="-1.57 1.57"/>
+            <geom name="link3_geom" type="box" size="0.05 0.05 0.1" mass="0.2"/>
+          </body>
+        </body>
+      </body>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+
+@pytest.fixture(scope="module")
+def device():
+  """Test device fixture."""
+  return get_test_device()
+
+
+class SimpleTestReward:
+  """A simple class-based reward for testing that tracks state."""
+
+  def __init__(self, cfg: RewardTermCfg, env):
+    self.num_envs = env.num_envs
+    self.device = env.device
+    self.current_air_time = torch.zeros((self.num_envs, 1), device=self.device)
+
+  def __call__(self, env, **kwargs):
+    self.current_air_time += 0.01
+    return torch.ones(env.num_envs, device=env.device)
+
+  def reset(self, env_ids: torch.Tensor | None = None, env=None):
+    if env_ids is not None and len(env_ids) > 0:
+      self.current_air_time[env_ids] = 0
+
+
+class StatelessReward:
+  """A stateless class-based reward without reset method."""
+
+  def __init__(self, cfg: RewardTermCfg, env):
+    pass
+
+  def __call__(self, env, **kwargs):
+    return torch.ones(env.num_envs)
+
+
+@pytest.fixture
+def mock_env():
+  """Create a mock environment for testing."""
+  env = Mock()
+  env.num_envs = 4
+  env.device = "cpu"
+  env.step_dt = 0.01
+  env.max_episode_length_s = 10.0
+  robot = Mock()
+  env.scene = {"robot": robot}
+  env.command_manager.get_command = Mock(
+    return_value=torch.tensor([[1.0, 0.0, 0.0]] * 4)
+  )
+  return env
+
+
+@pytest.fixture
+def class_reward_config():
+  """Config with a class-based reward."""
+  return {
+    "term": RewardTermCfg(
+      func=SimpleTestReward,
+      weight=1.0,
+      params={},
+    )
+  }
+
+
+@pytest.fixture
+def function_reward_config():
+  """Config with a function-based reward."""
+  return {
+    "term": RewardTermCfg(
+      func=lambda env: torch.ones(env.num_envs),
+      weight=1.0,
+      params={},
+    )
+  }
+
+
+@pytest.fixture
+def stateless_reward_config():
+  """Config with a stateless class-based reward."""
+  return {
+    "term": RewardTermCfg(
+      func=StatelessReward,
+      weight=1.0,
+      params={},
+    )
+  }
+
+
+def test_class_based_reward_reset(mock_env, class_reward_config):
+  """Test that class-based reward terms are tracked and have reset called."""
+  manager = RewardManager(class_reward_config, mock_env)
+  term = manager._class_term_cfgs[0].func
+
+  for _ in range(10):
+    manager.compute(dt=0.01)
+  assert (term.current_air_time > 0).all()
+
+  manager.reset(env_ids=torch.tensor([0, 2]))
+
+  # Check that only specified envs were reset.
+  assert term.current_air_time[0, 0] == 0
+  assert term.current_air_time[1, 0] > 0
+  assert term.current_air_time[2, 0] == 0
+  assert term.current_air_time[3, 0] > 0
+
+
+def test_function_based_reward_not_tracked(mock_env, function_reward_config):
+  """Test that function-based reward terms are not tracked as class terms."""
+  manager = RewardManager(function_reward_config, mock_env)
+  assert len(manager._class_term_cfgs) == 0
+
+
+def test_stateless_class_reward_no_reset(mock_env, stateless_reward_config):
+  """Test that stateless class-based rewards without reset don't break reset."""
+  manager = RewardManager(stateless_reward_config, mock_env)
+
+  # Stateless rewards without reset method should not be tracked.
+  assert len(manager._class_term_cfgs) == 0
+
+  # Reset should work without errors.
+  manager.reset(env_ids=torch.tensor([0, 2]))
+
+
+def test_electrical_power_cost_partially_actuated(device):
+  """Test electrical_power_cost on robots with passive joints.
+
+  This test verifies that:
+  1. The reward correctly identifies and uses only actuated joints (ignoring passive joints)
+  2. Power cost is computed as sum of max(0, force*velocity) for each actuator,
+     meaning only positive work is penalized (not regenerative braking)
+  """
+  entity_cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(PARTIALLY_ACTUATED_ROBOT_XML),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinPositionActuatorCfg(
+          target_names_expr=("actuated_joint1", "actuated_joint2"),
+          effort_limit=10.0,
+          stiffness=100.0,
+          damping=10.0,
+        ),
+      )
+    ),
+  )
+  entity = Entity(entity_cfg)
+  model = entity.compile()
+
+  num_envs = 2
+  sim_cfg = SimulationCfg()
+  sim = Simulation(num_envs=num_envs, cfg=sim_cfg, model=model, device=device)
+  entity.initialize(model, sim.model, sim.data, device)
+
+  env = Mock()
+  env.num_envs = num_envs
+  env.device = device
+  env.scene = {"robot": entity}
+
+  asset_cfg = SceneEntityCfg(name="robot", joint_names=("actuated.*",))
+
+  reward_cfg = RewardTermCfg(
+    func=electrical_power_cost, weight=1.0, params={"asset_cfg": asset_cfg}
+  )
+
+  reward = electrical_power_cost(reward_cfg, env)
+
+  assert len(reward._joint_ids) == 2
+
+  # Test case 1: All forces and velocities aligned (all positive work).
+  # actuated_joint1 (dof 0), actuated_joint2 (dof 2).
+  # Note: dof 1 is the passive joint, not used in power calculation.
+  sim.data.qfrc_actuator[:] = 0.0
+  sim.data.qfrc_actuator[:, 0] = torch.tensor([2.0, 1.0], device=device)
+  sim.data.qfrc_actuator[:, 2] = torch.tensor([3.0, 4.0], device=device)
+  sim.data.qvel[:] = 0.0
+  sim.data.qvel[:, 0] = torch.tensor([1.0, 2.0], device=device)
+  sim.data.qvel[:, 2] = torch.tensor([2.0, 1.0], device=device)
+
+  power_cost = reward(env, asset_cfg)
+
+  # Expected: env0 = 2.0*1.0 + 3.0*2.0 = 8.0, env1 = 1.0*2.0 + 4.0*1.0 = 6.0.
+  expected = torch.tensor([8.0, 6.0], device=device)
+  assert torch.allclose(power_cost, expected)
+
+  # Test case 2: Some negative forces (regenerative braking, not penalized).
+  sim.data.qfrc_actuator[:] = 0.0
+  sim.data.qfrc_actuator[:, 0] = torch.tensor([-2.0, 1.0], device=device)
+  sim.data.qfrc_actuator[:, 2] = torch.tensor([3.0, -4.0], device=device)
+
+  power_cost = reward(env, asset_cfg)
+
+  # Expected: env0 = max(0,-2.0*1.0) + max(0,3.0*2.0) = 0 + 6.0 = 6.0.
+  #           env1 = max(0,1.0*2.0) + max(0,-4.0*1.0) = 2.0 + 0 = 2.0.
+  expected = torch.tensor([6.0, 2.0], device=device)
+  assert torch.allclose(power_cost, expected)
+
+
+def test_reward_manager_handles_nan_values(mock_env):
+  """Test that RewardManager converts NaN/Inf reward values to zero."""
+
+  def nan_reward(env):
+    """Reward function that returns NaN for some environments."""
+    r = torch.ones(env.num_envs, device=env.device)
+    r[1] = float("nan")
+    r[3] = float("inf")
+    return r
+
+  cfg = {"nan_term": RewardTermCfg(func=nan_reward, weight=1.0, params={})}
+  manager = RewardManager(cfg, mock_env)
+
+  rewards = manager.compute(dt=0.01)
+
+  # NaN and Inf should be converted to 0.
+  assert not torch.isnan(rewards).any(), "Reward buffer contains NaN"
+  assert not torch.isinf(rewards).any(), "Reward buffer contains Inf"
+  assert rewards[0] == pytest.approx(0.01)
+  assert rewards[1] == 0.0
+  assert rewards[2] == pytest.approx(0.01)
+  assert rewards[3] == 0.0
+
+
+def test_reward_manager_handles_neginf_values(mock_env):
+  """Test that RewardManager converts negative infinity to zero."""
+
+  def neginf_reward(env):
+    r = torch.ones(env.num_envs, device=env.device)
+    r[2] = float("-inf")
+    return r
+
+  cfg = {"neginf_term": RewardTermCfg(func=neginf_reward, weight=1.0, params={})}
+  manager = RewardManager(cfg, mock_env)
+
+  rewards = manager.compute(dt=0.01)
+
+  assert not torch.isinf(rewards).any()
+  assert rewards[2] == 0.0
+
+
+def test_reward_scaling_enabled(mock_env):
+  """Test that rewards are scaled by dt when scale_by_dt=True (default)."""
+
+  def constant_reward(env):
+    return torch.ones(env.num_envs, device=env.device)
+
+  cfg = {"term": RewardTermCfg(func=constant_reward, weight=2.0, params={})}
+  manager = RewardManager(cfg, mock_env, scale_by_dt=True)
+
+  dt = 0.02
+  rewards = manager.compute(dt=dt)
+
+  # With scaling: reward = raw_value (1.0) * weight (2.0) * dt (0.02) = 0.04
+  expected = 1.0 * 2.0 * dt
+  assert torch.allclose(rewards, torch.full((4,), expected))
+
+  # _step_reward should be unscaled (raw_value * weight)
+  step_reward = manager._step_reward[:, 0]
+  expected_step = 1.0 * 2.0
+  assert torch.allclose(step_reward, torch.full((4,), expected_step))
+
+
+def test_reward_scaling_disabled(mock_env):
+  """Test that rewards are not scaled by dt when scale_by_dt=False."""
+
+  def constant_reward(env):
+    return torch.ones(env.num_envs, device=env.device)
+
+  cfg = {"term": RewardTermCfg(func=constant_reward, weight=2.0, params={})}
+  manager = RewardManager(cfg, mock_env, scale_by_dt=False)
+
+  dt = 0.02
+  rewards = manager.compute(dt=dt)
+
+  # Without scaling: reward = raw_value (1.0) * weight (2.0) = 2.0
+  expected = 1.0 * 2.0
+  assert torch.allclose(rewards, torch.full((4,), expected))
+
+  # _step_reward should still be unscaled (same as reward when not scaling)
+  step_reward = manager._step_reward[:, 0]
+  assert torch.allclose(step_reward, torch.full((4,), expected))
+
+
+def test_reward_scaling_default_is_enabled(mock_env):
+  """Test that scale_by_dt defaults to True for backward compatibility."""
+
+  def constant_reward(env):
+    return torch.ones(env.num_envs, device=env.device)
+
+  cfg = {"term": RewardTermCfg(func=constant_reward, weight=1.0, params={})}
+  # Don't pass scale_by_dt - should default to True
+  manager = RewardManager(cfg, mock_env)
+
+  dt = 0.01
+  rewards = manager.compute(dt=dt)
+
+  # Default (scaling enabled): reward = 1.0 * 1.0 * 0.01 = 0.01
+  assert torch.allclose(rewards, torch.full((4,), 0.01))
+
+
+def test_reward_shape_validation_rejects_bad_compute_output(mock_env):
+  """Reward terms must return one scalar per environment."""
+  cfg = {"bad": RewardTermCfg(func=lambda env: torch.ones(env.num_envs, 1), weight=1.0)}
+  manager = RewardManager(cfg, mock_env)
+  with pytest.raises(ValueError, match="RewardManager term 'bad'.*expected \\(4,\\)"):
+    manager.compute(dt=0.01)
+
+
+def test_joint_torques_l2_with_actuator_ids(mock_env):
+  """Test that joint_torques_l2 only penalizes specified actuators."""
+  mock_env.scene["robot"].data.actuator_force = torch.tensor([[1.0, 2.0, 3.0, 4.0]] * 4)
+
+  asset_cfg = SceneEntityCfg(name="robot", actuator_ids=[0, 2])
+  result = joint_torques_l2(mock_env, asset_cfg)
+
+  # Only actuators 0 and 2: 1^2 + 3^2 = 10.0
+  expected = torch.full((4,), 10.0)
+  assert torch.allclose(result, expected)
+
+
+def test_joint_torques_l2_all_actuators(mock_env):
+  """Test that joint_torques_l2 uses all actuators by default."""
+  mock_env.scene["robot"].data.actuator_force = torch.tensor([[1.0, 2.0, 3.0]] * 4)
+
+  asset_cfg = SceneEntityCfg(name="robot")
+  result = joint_torques_l2(mock_env, asset_cfg)
+
+  # All actuators: 1^2 + 2^2 + 3^2 = 14.0
+  expected = torch.full((4,), 14.0)
+  assert torch.allclose(result, expected)
diff --git a/tests/test_rl_exporter.py b/tests/test_rl_exporter.py
new file mode 100644
index 0000000..1303c6e
--- /dev/null
+++ b/tests/test_rl_exporter.py
@@ -0,0 +1,346 @@
+"""Tests for RL exporter utilities."""
+
+import os
+import tempfile
+
+import mujoco
+import onnx
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.actuator import XmlActuatorCfg
+from mjlab.entity import EntityArticulationInfoCfg, EntityCfg
+from mjlab.envs import ManagerBasedRlEnv, ManagerBasedRlEnvCfg, mdp
+from mjlab.managers.observation_manager import ObservationGroupCfg, ObservationTermCfg
+from mjlab.rl.exporter_utils import (
+  attach_metadata_to_onnx,
+  get_base_metadata,
+  list_to_csv_str,
+)
+from mjlab.scene import SceneCfg
+from mjlab.sim import MujocoCfg, SimulationCfg
+from mjlab.terrains import TerrainEntityCfg
+
+
+def test_list_to_csv_str():
+  """Test CSV string conversion utility."""
+  # Test with floats.
+  result = list_to_csv_str([1.23456, 2.34567, 3.45678], decimals=3)
+  assert result == "1.235,2.346,3.457"
+
+  # Test with integers.
+  result = list_to_csv_str([1, 2, 3], decimals=2)
+  assert result == "1.00,2.00,3.00"
+
+  # Test with mixed types.
+  result = list_to_csv_str([1.5, "hello", 2.5], decimals=1)
+  assert result == "1.5,hello,2.5"
+
+  # Test custom delimiter.
+  result = list_to_csv_str([1.0, 2.0, 3.0], decimals=1, delimiter=";")
+  assert result == "1.0;2.0;3.0"
+
+  # Test nested sequence entries (e.g. per-term clip ranges or vector scales):
+  # each entry is joined with the sub-delimiter so the outer delimiter stays
+  # unambiguous and round-trips via a plain split.
+  result = list_to_csv_str([[1.0, 2.0], 3.0, [4.0, 5.0]], decimals=1)
+  assert result == "1.0;2.0,3.0,4.0;5.0"
+  entries = result.split(",")
+  assert entries == ["1.0;2.0", "3.0", "4.0;5.0"]
+  assert entries[0].split(";") == ["1.0", "2.0"]
+
+
+def test_attach_metadata_to_onnx():
+  """Test that metadata can be attached to ONNX models."""
+  # Create a dummy ONNX model.
+  with tempfile.TemporaryDirectory() as tmpdir:
+    onnx_path = os.path.join(tmpdir, "test_policy.onnx")
+
+    # Create minimal ONNX model.
+    input_tensor = onnx.helper.make_tensor_value_info(
+      "input", onnx.TensorProto.FLOAT, [1, 2]
+    )
+    output_tensor = onnx.helper.make_tensor_value_info(
+      "output", onnx.TensorProto.FLOAT, [1, 2]
+    )
+    node = onnx.helper.make_node("Identity", ["input"], ["output"])
+    graph = onnx.helper.make_graph(
+      [node], "test_graph", [input_tensor], [output_tensor]
+    )
+    model = onnx.helper.make_model(graph)
+    onnx.save(model, onnx_path)
+
+    # Attach metadata.
+    metadata = {
+      "run_path": "test/run/path",
+      "joint_names": ["joint_a", "joint_b"],
+      "joint_stiffness": [20.0, 10.0],
+      "joint_damping": [1.0, 1.0],
+      "extra_field": "extra_value",
+    }
+    attach_metadata_to_onnx(onnx_path, metadata)
+
+    # Load and verify metadata was attached.
+    loaded_model = onnx.load(onnx_path)
+    metadata_props = {prop.key: prop.value for prop in loaded_model.metadata_props}
+
+    # Check all metadata fields are present.
+    assert "run_path" in metadata_props
+    assert "joint_names" in metadata_props
+    assert "joint_stiffness" in metadata_props
+    assert "extra_field" in metadata_props
+
+    # Check values are correct.
+    assert metadata_props["run_path"] == "test/run/path"
+    assert metadata_props["extra_field"] == "extra_value"
+
+    # Check list was converted to CSV string.
+    joint_names = metadata_props["joint_names"].split(",")
+    assert len(joint_names) == 2
+    assert "joint_a" in joint_names
+    assert "joint_b" in joint_names
+
+    # Check stiffness values are in natural joint order.
+    stiffness_values = [float(x) for x in metadata_props["joint_stiffness"].split(",")]
+    assert stiffness_values == [20.0, 10.0]  # Natural order: joint_a (20), joint_b (10)
+
+
+def test_attach_metadata_to_onnx_nested_clip_and_scale():
+  """Per-term clip ranges and vector scales must round-trip through a plain
+  comma split without corrupting neighboring entries."""
+  with tempfile.TemporaryDirectory() as tmpdir:
+    onnx_path = os.path.join(tmpdir, "test_policy.onnx")
+
+    input_tensor = onnx.helper.make_tensor_value_info(
+      "input", onnx.TensorProto.FLOAT, [1, 2]
+    )
+    output_tensor = onnx.helper.make_tensor_value_info(
+      "output", onnx.TensorProto.FLOAT, [1, 2]
+    )
+    node = onnx.helper.make_node("Identity", ["input"], ["output"])
+    graph = onnx.helper.make_graph(
+      [node], "test_graph", [input_tensor], [output_tensor]
+    )
+    model = onnx.helper.make_model(graph)
+    onnx.save(model, onnx_path)
+
+    metadata = {
+      "observation_terms_clip": [
+        [float("-inf"), float("inf")],
+        [-1.0, 1.0],
+        [float("-inf"), float("inf")],
+      ],
+      "observation_terms_scale": [1.0, [0.5, 1.2, 0.3], 2.0],
+    }
+    attach_metadata_to_onnx(onnx_path, metadata)
+
+    loaded_model = onnx.load(onnx_path)
+    metadata_props = {prop.key: prop.value for prop in loaded_model.metadata_props}
+
+    clip_entries = metadata_props["observation_terms_clip"].split(",")
+    assert clip_entries == ["-inf;inf", "-1.000;1.000", "-inf;inf"]
+    assert [float(x) for x in clip_entries[1].split(";")] == [-1.0, 1.0]
+
+    scale_entries = metadata_props["observation_terms_scale"].split(",")
+    assert scale_entries == ["1.000", "0.500;1.200;0.300", "2.000"]
+    assert [float(x) for x in scale_entries[1].split(";")] == [0.5, 1.2, 0.3]
+
+
+# Robot with 2 joints but only 1 actuator (underactuated).
+ROBOT_XML_UNDERACTUATED = """
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="1.0"/>
+      <body name="link1" pos="0 0 0">
+        <joint name="joint1" type="hinge" axis="0 0 1" range="-1.57 1.57"/>
+        <geom name="link1_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+      </body>
+      <body name="link2" pos="0 0 0">
+        <joint name="joint2" type="hinge" axis="0 0 1" range="-1.57 1.57"/>
+        <geom name="link2_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+      </body>
+    </body>
+  </worldbody>
+  <actuator>
+    <motor name="actuator1" joint="joint2" gear="1.0"/>
+  </actuator>
+</mujoco>
+"""
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+def test_get_base_metadata_skips_non_actuated_joints(device):
+  """get_base_metadata handles non-actuated joints without KeyError."""
+  robot_cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML_UNDERACTUATED),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(XmlActuatorCfg(target_names_expr=(".*",)),)
+    ),
+  )
+
+  env_cfg = ManagerBasedRlEnvCfg(
+    scene=SceneCfg(
+      terrain=TerrainEntityCfg(terrain_type="plane"),
+      num_envs=1,
+      extent=1.0,
+      entities={"robot": robot_cfg},
+    ),
+    observations={
+      "actor": ObservationGroupCfg(
+        terms={
+          "joint_pos": ObservationTermCfg(
+            func=lambda env: env.scene["robot"].data.joint_pos,
+            history_length=5,
+            scale=2.0,
+          ),
+        },
+      ),
+    },
+    actions={
+      "joint_pos": mdp.JointPositionActionCfg(
+        entity_name="robot", actuator_names=(".*",), scale=1.0
+      )
+    },
+    sim=SimulationCfg(mujoco=MujocoCfg(timestep=0.01, iterations=1)),
+    decimation=1,
+    episode_length_s=1.0,
+  )
+
+  env = ManagerBasedRlEnv(cfg=env_cfg, device=device)
+  metadata = get_base_metadata(env, run_path="dummy/run")
+
+  robot = env.scene["robot"]
+
+  # All joints (including non-actuated) should be listed in joint_names metadata.
+  joint_names_meta = metadata["joint_names"]
+  assert isinstance(joint_names_meta, list)
+  assert joint_names_meta == list(robot.joint_names)
+  assert "joint1" in joint_names_meta
+  assert "joint2" in joint_names_meta
+
+  # Stiffness/damping are only defined for actuated joints, in natural joint order.
+  stiffness_meta = metadata["joint_stiffness"]
+  damping_meta = metadata["joint_damping"]
+  assert isinstance(stiffness_meta, list)
+  assert isinstance(damping_meta, list)
+  assert len(stiffness_meta) == len(robot.spec.actuators)
+  assert len(damping_meta) == len(robot.spec.actuators)
+
+  observation_names = metadata["observation_names"]
+  assert isinstance(observation_names, list)
+  assert "joint_pos" in observation_names
+
+  observation_terms_scale = metadata["observation_terms_scale"]
+  assert isinstance(observation_terms_scale, list)
+  assert len(observation_terms_scale) == len(observation_names)
+  assert observation_terms_scale[0] == 2.0
+
+  observation_history_length = metadata["observation_terms_history_length"]
+  assert isinstance(observation_history_length, list)
+  assert len(observation_history_length) == len(observation_names)
+  assert observation_history_length[0] == 5
+
+  observation_flatten_history_dim = metadata["observation_terms_flatten_history_dim"]
+  assert isinstance(observation_flatten_history_dim, list)
+  assert len(observation_flatten_history_dim) == len(observation_names)
+  # Default flatten_history_dim is 1.0 (True)
+  assert observation_flatten_history_dim[0] is True
+
+  observation_terms_clip = metadata["observation_terms_clip"]
+  assert isinstance(observation_terms_clip, list)
+  assert len(observation_terms_clip) == len(observation_names)
+  # Default clip is [-inf, inf]
+  assert observation_terms_clip[0] == [float("-inf"), float("inf")]
+
+  env.close()
+
+
+def test_get_base_metadata_multiple_terms_scale_clip(device):
+  """get_base_metadata preserves obs term ordering and handles scalar/vector tensor scale, tuple scale, and non-default clip."""
+  robot_cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML_UNDERACTUATED),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(XmlActuatorCfg(target_names_expr=(".*",)),)
+    ),
+  )
+
+  env_cfg = ManagerBasedRlEnvCfg(
+    scene=SceneCfg(
+      terrain=TerrainEntityCfg(terrain_type="plane"),
+      num_envs=1,
+      extent=1.0,
+      entities={"robot": robot_cfg},
+    ),
+    observations={
+      "actor": ObservationGroupCfg(
+        terms={
+          "joint_pos": ObservationTermCfg(
+            func=lambda env: env.scene["robot"].data.joint_pos,
+            scale=torch.tensor(
+              2.0
+            ),  # tensor scale -> should be converted via .tolist()
+            history_length=1,
+          ),
+          "joint_vel": ObservationTermCfg(
+            func=lambda env: env.scene["robot"].data.joint_vel,
+            scale=(0.5, 1.5),  # tuple scale -> stored as-is
+            clip=(-1.0, 1.0),  # non-default clip
+            history_length=1,
+          ),
+          "joint_pos_scaled": ObservationTermCfg(
+            func=lambda env: env.scene["robot"].data.joint_pos,
+            scale=torch.tensor([1.0, 2.0]),  # per-element tensor -> list of floats
+            history_length=1,
+          ),
+        },
+      ),
+    },
+    actions={
+      "joint_pos": mdp.JointPositionActionCfg(
+        entity_name="robot", actuator_names=(".*",), scale=1.0
+      )
+    },
+    sim=SimulationCfg(mujoco=MujocoCfg(timestep=0.01, iterations=1)),
+    decimation=1,
+    episode_length_s=1.0,
+  )
+
+  env = ManagerBasedRlEnv(cfg=env_cfg, device=device)
+  metadata = get_base_metadata(env, run_path="dummy/run")
+
+  observation_names = metadata["observation_names"]
+  scales = metadata["observation_terms_scale"]
+  clips = metadata["observation_terms_clip"]
+  assert isinstance(observation_names, list)
+  assert isinstance(scales, list)
+  assert isinstance(clips, list)
+
+  # Terms appear in definition order.
+  assert observation_names == ["joint_pos", "joint_vel", "joint_pos_scaled"]
+
+  # Scalar tensor scale is unwrapped to a plain float.
+  assert scales[0] == 2.0
+
+  # Tuple scale is stored as list.
+  assert scales[1] == [0.5, 1.5]
+
+  # Per-element tensor scale is converted to a list of floats.
+  assert scales[2] == [1.0, 2.0]
+
+  # joint_pos has default clip.
+  assert clips[0] == [float("-inf"), float("inf")]
+
+  # joint_vel has explicit clip converted to list.
+  assert clips[1] == [-1.0, 1.0]
+
+  # joint_pos_scaled has default clip.
+  assert clips[2] == [float("-inf"), float("inf")]
+
+  env.close()
diff --git a/tests/test_runner.py b/tests/test_runner.py
new file mode 100644
index 0000000..fb1816d
--- /dev/null
+++ b/tests/test_runner.py
@@ -0,0 +1,661 @@
+"""Tests for MjlabOnPolicyRunner."""
+
+import ast
+import tempfile
+from dataclasses import asdict
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import mujoco
+import onnx
+import pytest
+import torch
+from conftest import get_test_device
+from rsl_rl.models import MLPModel
+from rsl_rl.utils import WandbLogWriter
+from rsl_rl.utils.logger import Logger
+from tensordict import TensorDict
+
+import mjlab.scripts.train as train_mod
+from mjlab.actuator import XmlActuatorCfg
+from mjlab.entity import EntityArticulationInfoCfg, EntityCfg
+from mjlab.envs import ManagerBasedRlEnv, ManagerBasedRlEnvCfg, mdp
+from mjlab.managers.observation_manager import ObservationGroupCfg, ObservationTermCfg
+from mjlab.rl import RslRlOnPolicyRunnerCfg, RslRlVecEnvWrapper
+from mjlab.rl.runner import MjlabOnPolicyRunner
+from mjlab.rl.spatial_softmax import SpatialSoftmaxCNNModel
+from mjlab.scene import SceneCfg
+from mjlab.sim import MujocoCfg, SimulationCfg
+from mjlab.tasks.tracking.rl.runner import _OnnxMotionModel
+from mjlab.terrains import TerrainEntityCfg
+from mjlab.utils.os import dump_yaml
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+@pytest.fixture(scope="module")
+def env(device):
+  robot_xml = """
+  <mujoco>
+    <worldbody>
+      <body name="base" pos="0 0 1">
+        <freejoint name="free_joint"/>
+        <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="1.0"/>
+        <body name="link1" pos="0 0 0">
+          <joint name="joint1" type="hinge" axis="0 0 1" range="-1.57 1.57"/>
+          <geom name="link1_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+        </body>
+      </body>
+    </worldbody>
+    <actuator>
+      <motor name="actuator1" joint="joint1" gear="1.0"/>
+    </actuator>
+  </mujoco>
+  """
+  robot_cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(robot_xml),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(XmlActuatorCfg(target_names_expr=(".*",)),)
+    ),
+  )
+
+  env_cfg = ManagerBasedRlEnvCfg(
+    scene=SceneCfg(
+      terrain=TerrainEntityCfg(terrain_type="plane"),
+      num_envs=2,
+      extent=1.0,
+      entities={"robot": robot_cfg},
+    ),
+    observations={
+      "actor": ObservationGroupCfg(
+        terms={
+          "joint_pos": ObservationTermCfg(
+            func=lambda env: env.scene["robot"].data.joint_pos
+          ),
+        },
+      ),
+      "critic": ObservationGroupCfg(
+        terms={
+          "joint_pos": ObservationTermCfg(
+            func=lambda env: env.scene["robot"].data.joint_pos
+          ),
+        },
+      ),
+    },
+    actions={
+      "joint_pos": mdp.JointPositionActionCfg(
+        entity_name="robot", actuator_names=(".*",), scale=1.0
+      )
+    },
+    sim=SimulationCfg(mujoco=MujocoCfg(timestep=0.01, iterations=1)),
+    decimation=1,
+    episode_length_s=1.0,
+  )
+
+  env = ManagerBasedRlEnv(cfg=env_cfg, device=device)
+  yield env
+  env.close()
+
+
+def test_runner_persists_common_step_counter(env, device, monkeypatch):
+  """MjlabOnPolicyRunner should save and restore common_step_counter."""
+  wrapped_env = RslRlVecEnvWrapper(env)
+  agent_cfg = RslRlOnPolicyRunnerCfg(
+    num_steps_per_env=4, max_iterations=10, save_interval=5
+  )
+
+  with tempfile.TemporaryDirectory() as tmpdir:
+    runner = MjlabOnPolicyRunner(
+      wrapped_env, asdict(agent_cfg), log_dir=tmpdir, device=device
+    )
+    monkeypatch.setattr(runner.logger, "save_model", lambda *args, **kwargs: None)
+
+    wrapped_env.unwrapped.common_step_counter = 12345
+    checkpoint_path = str(Path(tmpdir) / "test_checkpoint.pt")
+    runner.save(checkpoint_path)
+
+    wrapped_env.unwrapped.common_step_counter = 0
+    runner.load(checkpoint_path)
+
+    assert wrapped_env.unwrapped.common_step_counter == 12345
+
+
+def test_runner_handles_old_checkpoints_without_env_state(env, device):
+  """Old checkpoints without env_state should load without crashing."""
+
+  wrapped_env = RslRlVecEnvWrapper(env)
+  agent_cfg = RslRlOnPolicyRunnerCfg(
+    num_steps_per_env=4, max_iterations=10, save_interval=5
+  )
+
+  with tempfile.TemporaryDirectory() as tmpdir:
+    runner = MjlabOnPolicyRunner(
+      wrapped_env, asdict(agent_cfg), log_dir=tmpdir, device=device
+    )
+
+    checkpoint_path = str(Path(tmpdir) / "old_checkpoint.pt")
+    old_checkpoint = {
+      "actor_state_dict": runner.alg.actor.state_dict(),
+      "critic_state_dict": runner.alg.critic.state_dict(),
+      "optimizer_state_dict": runner.alg.optimizer.state_dict(),
+      "iter": 100,
+      "infos": None,
+    }
+    torch.save(old_checkpoint, checkpoint_path)
+
+    wrapped_env.unwrapped.common_step_counter = 999
+    runner.load(checkpoint_path)
+
+    assert wrapped_env.unwrapped.common_step_counter == 999
+
+
+@pytest.mark.filterwarnings("ignore::DeprecationWarning")
+def test_export_policy_to_onnx(env, device):
+  """runner.export_policy_to_onnx() produces a valid ONNX file."""
+  wrapped_env = RslRlVecEnvWrapper(env)
+  agent_cfg = RslRlOnPolicyRunnerCfg(
+    num_steps_per_env=4, max_iterations=10, save_interval=5
+  )
+
+  with tempfile.TemporaryDirectory() as tmpdir:
+    runner = MjlabOnPolicyRunner(
+      wrapped_env, asdict(agent_cfg), log_dir=tmpdir, device=device
+    )
+    runner.export_policy_to_onnx(tmpdir, "test_policy.onnx")
+    onnx_path = Path(tmpdir) / "test_policy.onnx"
+    assert onnx_path.exists()
+    onnx.checker.check_model(str(onnx_path))
+
+
+def _make_actor(obs_dim=8, output_dim=4, obs_normalization=True):
+  obs = TensorDict({"actor": torch.zeros(1, obs_dim)})
+  obs_groups = {"actor": ["actor"]}
+  return MLPModel(
+    obs=obs,
+    obs_groups=obs_groups,
+    obs_set="actor",
+    output_dim=output_dim,
+    hidden_dims=[32, 32],
+    activation="elu",
+    obs_normalization=obs_normalization,
+  )
+
+
+def _train_normalizer(actor, n_batches=50, batch_size=64):
+  actor.train()
+  for _ in range(n_batches):
+    obs = TensorDict({"actor": torch.randn(batch_size, actor.obs_dim) * 5 + 3})
+    actor.update_normalization(obs)
+  actor.eval()
+
+
+def _model_output(actor, x_flat):
+  obs = TensorDict({"actor": x_flat})
+  with torch.no_grad():
+    return actor(obs)
+
+
+def test_onnx_export_matches_actor():
+  """as_onnx() model produces the same output as the full actor with normalization."""
+  actor = _make_actor(obs_normalization=True)
+  _train_normalizer(actor)
+  onnx_model = actor.as_onnx(verbose=False)
+  onnx_model.eval()
+  x = torch.randn(4, actor.obs_dim)
+  model_out = _model_output(actor, x)
+  with torch.no_grad():
+    onnx_out = onnx_model(x)
+  torch.testing.assert_close(model_out, onnx_out, atol=1e-6, rtol=0)
+
+
+def test_onnx_export_without_normalization():
+  """as_onnx() works when normalization is disabled."""
+  actor = _make_actor(obs_normalization=False)
+  onnx_model = actor.as_onnx(verbose=False)
+  onnx_model.eval()
+  x = torch.randn(4, actor.obs_dim)
+  with torch.no_grad():
+    out = onnx_model(x)
+  assert out.shape == (4, 4)
+
+
+@pytest.mark.filterwarnings("ignore::DeprecationWarning")
+def test_onnx_runtime_roundtrip_matches_pytorch():
+  """Exported .onnx file produces the same outputs as PyTorch via onnxruntime."""
+  ort = pytest.importorskip("onnxruntime")
+  actor = _make_actor(obs_normalization=True)
+  _train_normalizer(actor)
+  onnx_model = actor.as_onnx(verbose=False)
+  onnx_model.eval()
+
+  x = torch.randn(4, actor.obs_dim)
+  expected = _model_output(actor, x)
+
+  with tempfile.TemporaryDirectory() as tmpdir:
+    path = Path(tmpdir) / "policy.onnx"
+    torch.onnx.export(
+      onnx_model,
+      (x,),
+      str(path),
+      input_names=onnx_model.input_names,  # pyright: ignore[reportArgumentType]
+      output_names=onnx_model.output_names,  # pyright: ignore[reportArgumentType]
+      opset_version=18,
+      dynamo=False,
+    )
+    sess = ort.InferenceSession(str(path))
+    [actual] = sess.run(None, {"obs": x.numpy()})
+
+  torch.testing.assert_close(torch.from_numpy(actual), expected, atol=1e-5, rtol=0)
+
+
+# CNN (spatial-softmax) ONNX export tests.
+
+_IMG_H, _IMG_W, _IMG_C = 16, 16, 3
+_OBS_DIM_1D = 8
+_OUTPUT_DIM = 4
+
+
+def _make_cnn_actor(obs_normalization=True):
+  obs = TensorDict(
+    {
+      "actor": torch.zeros(1, _OBS_DIM_1D),
+      "camera": torch.zeros(1, _IMG_C, _IMG_H, _IMG_W),
+    }
+  )
+  obs_groups = {"actor": ["actor", "camera"]}
+  cnn_cfg = {
+    "output_channels": [8],
+    "kernel_size": [3],
+    "stride": [1],
+    "spatial_softmax_temperature": 1.0,
+  }
+  return SpatialSoftmaxCNNModel(
+    obs=obs,
+    obs_groups=obs_groups,
+    obs_set="actor",
+    output_dim=_OUTPUT_DIM,
+    cnn_cfg=cnn_cfg,
+    hidden_dims=[32, 32],
+    activation="elu",
+    obs_normalization=obs_normalization,
+  )
+
+
+def _train_cnn_normalizer(actor, n_batches=50, batch_size=64):
+  actor.train()
+  for _ in range(n_batches):
+    obs = TensorDict(
+      {
+        "actor": torch.randn(batch_size, _OBS_DIM_1D) * 5 + 3,
+        "camera": torch.randn(batch_size, _IMG_C, _IMG_H, _IMG_W),
+      }
+    )
+    actor.update_normalization(obs)
+  actor.eval()
+
+
+def _cnn_model_output(actor, x_1d, x_2d):
+  obs = TensorDict({"actor": x_1d, "camera": x_2d})
+  with torch.no_grad():
+    return actor(obs)
+
+
+def test_cnn_onnx_export_matches_actor():
+  """as_onnx() with SpatialSoftmaxCNNModel matches the original model."""
+  actor = _make_cnn_actor(obs_normalization=True)
+  _train_cnn_normalizer(actor)
+
+  onnx_model = actor.as_onnx(verbose=False)
+  onnx_model.eval()
+
+  x_1d = torch.randn(4, _OBS_DIM_1D)
+  x_2d = torch.randn(4, _IMG_C, _IMG_H, _IMG_W)
+
+  expected = _cnn_model_output(actor, x_1d, x_2d)
+  with torch.no_grad():
+    actual = onnx_model(x_1d, x_2d)
+  torch.testing.assert_close(actual, expected, atol=1e-6, rtol=0)
+
+
+@pytest.mark.filterwarnings("ignore::DeprecationWarning")
+def test_cnn_onnx_export_to_file():
+  """SpatialSoftmaxCNNModel exports to a valid ONNX file."""
+  actor = _make_cnn_actor(obs_normalization=False)
+  onnx_model = actor.as_onnx(verbose=False)
+  onnx_model.to("cpu")
+  onnx_model.eval()
+
+  with tempfile.TemporaryDirectory() as tmpdir:
+    onnx_path = Path(tmpdir) / "cnn_policy.onnx"
+    torch.onnx.export(
+      onnx_model,
+      onnx_model.get_dummy_inputs(),  # pyright: ignore[reportCallIssue]
+      str(onnx_path),
+      export_params=True,
+      opset_version=18,
+      input_names=onnx_model.input_names,  # pyright: ignore[reportArgumentType]
+      output_names=onnx_model.output_names,  # pyright: ignore[reportArgumentType]
+      dynamic_axes={},
+      dynamo=False,
+    )
+    assert onnx_path.exists()
+    onnx.checker.check_model(str(onnx_path))
+
+
+@pytest.mark.filterwarnings("ignore::DeprecationWarning")
+def test_cnn_onnx_runtime_roundtrip_matches_pytorch():
+  """Exported CNN .onnx file produces the same outputs as PyTorch via onnxruntime."""
+  ort = pytest.importorskip("onnxruntime")
+  actor = _make_cnn_actor(obs_normalization=True)
+  _train_cnn_normalizer(actor)
+
+  onnx_model = actor.as_onnx(verbose=False)
+  onnx_model.eval()
+
+  x_1d = torch.randn(4, _OBS_DIM_1D)
+  x_2d = torch.randn(4, _IMG_C, _IMG_H, _IMG_W)
+  expected = _cnn_model_output(actor, x_1d, x_2d)
+
+  with tempfile.TemporaryDirectory() as tmpdir:
+    path = Path(tmpdir) / "cnn_policy.onnx"
+    torch.onnx.export(
+      onnx_model,
+      (x_1d, x_2d),
+      str(path),
+      input_names=onnx_model.input_names,  # pyright: ignore[reportArgumentType]
+      output_names=onnx_model.output_names,  # pyright: ignore[reportArgumentType]
+      opset_version=18,
+      dynamo=False,
+    )
+    sess = ort.InferenceSession(str(path))
+    [actual] = sess.run(None, {"obs": x_1d.numpy(), "camera": x_2d.numpy()})
+
+  torch.testing.assert_close(torch.from_numpy(actual), expected, atol=1e-5, rtol=0)
+
+
+def test_get_export_paths():
+  """_get_export_paths resolves the correct dir, filename, and full path."""
+  # Normal case: "model" only appears in the checkpoint filename.
+  export_dir, filename, onnx_path = MjlabOnPolicyRunner._get_export_paths(
+    "/logs/2026-03-30_12-00-00/model_10.pt"
+  )
+  assert export_dir == Path("/logs/2026-03-30_12-00-00")
+  assert filename == "2026-03-30_12-00-00.onnx"
+  assert onnx_path == Path("/logs/2026-03-30_12-00-00/2026-03-30_12-00-00.onnx")
+
+  # Bug case: "model" also appears in a parent directory name — the old
+  # path.split("model")[0] would have truncated to "/tmp/my_".
+  export_dir, filename, onnx_path = MjlabOnPolicyRunner._get_export_paths(
+    "/tmp/my_model_experiment/2026-03-30/model_10.pt"
+  )
+  assert export_dir == Path("/tmp/my_model_experiment/2026-03-30")
+  assert filename == "2026-03-30.onnx"
+  assert onnx_path == Path("/tmp/my_model_experiment/2026-03-30/2026-03-30.onnx")
+
+
+def test_agent_cfg_serializable_after_runner_creation(env, device):
+  """dump_yaml must be called before runner creation.
+
+  The runner mutates agent_cfg in-place (e.g. resolve_symmetry_config injects
+  non-serializable objects). Verify that the train script writes config files before
+  constructing the runner.
+
+  Regression test for https://github.com/mjlab-org/mjlab/issues/764.
+  """
+  wrapped_env = RslRlVecEnvWrapper(env)
+  agent_cfg = asdict(
+    RslRlOnPolicyRunnerCfg(num_steps_per_env=4, max_iterations=10, save_interval=5)
+  )
+
+  # Dump should succeed before runner creation.
+  with tempfile.TemporaryDirectory() as tmpdir:
+    dump_yaml(Path(tmpdir) / "agent.yaml", agent_cfg)
+
+  # Create runner (mutates agent_cfg via resolve_symmetry_config).
+  with tempfile.TemporaryDirectory() as tmpdir:
+    MjlabOnPolicyRunner(wrapped_env, agent_cfg, log_dir=tmpdir, device=device)
+
+  # Confirm that the runner added non-serializable keys to agent_cfg.
+  sym_cfg = agent_cfg.get("algorithm", {}).get("symmetry_cfg")
+  runner_mutated = sym_cfg is not None or "multi_gpu" in agent_cfg
+  assert runner_mutated, "Expected runner to mutate agent_cfg"
+
+  # Verify the train script calls dump_yaml before runner_cls().
+  source = Path(train_mod.__file__).read_text()
+  tree = ast.parse(source)
+
+  dump_yaml_line = None
+  runner_cls_line = None
+  for node in ast.walk(tree):
+    if isinstance(node, ast.Call):
+      func = node.func
+      # Look for dump_yaml(..., agent_cfg)
+      if isinstance(func, ast.Name) and func.id == "dump_yaml":
+        for arg in node.args:
+          if isinstance(arg, ast.Name) and arg.id == "agent_cfg":
+            dump_yaml_line = node.lineno
+      # Look for runner_cls(...)
+      if isinstance(func, ast.Name) and func.id == "runner_cls":
+        runner_cls_line = node.lineno
+
+  assert dump_yaml_line is not None, "dump_yaml(agent_cfg) not found"
+  assert runner_cls_line is not None, "runner_cls() not found"
+  assert dump_yaml_line < runner_cls_line, (
+    f"dump_yaml (line {dump_yaml_line}) must be called before "
+    f"runner_cls (line {runner_cls_line})"
+  )
+
+
+class _MockMotion:
+  """Minimal mock of a motion object with tensor attributes."""
+
+  def __init__(self, num_steps, num_joints=12, num_bodies=5):
+    self.joint_pos = torch.randn(num_steps, num_joints)
+    self.joint_vel = torch.randn(num_steps, num_joints)
+    self.body_pos_w = torch.randn(num_steps, num_bodies, 3)
+    self.body_quat_w = torch.randn(num_steps, num_bodies, 4)
+    self.body_lin_vel_w = torch.randn(num_steps, num_bodies, 3)
+    self.body_ang_vel_w = torch.randn(num_steps, num_bodies, 3)
+
+
+def test_onnx_motion_model_policy_matches_actor():
+  """_OnnxMotionModel actions output matches calling the actor directly."""
+
+  actor = _make_actor(obs_normalization=True)
+  _train_normalizer(actor)
+  motion = _MockMotion(num_steps=50)
+
+  model = _OnnxMotionModel(actor, motion)
+  model.eval()
+
+  x = torch.randn(4, actor.obs_dim)
+  time_step = torch.tensor([[5]], dtype=torch.float32)
+
+  with torch.no_grad():
+    actions, *_ = model(x, time_step)
+  expected = _model_output(actor, x)
+  torch.testing.assert_close(actions, expected, atol=1e-6, rtol=0)
+
+
+def test_onnx_motion_model_returns_correct_motion_frame():
+  """_OnnxMotionModel returns the motion data at the requested time step."""
+
+  actor = _make_actor(obs_normalization=False)
+  motion = _MockMotion(num_steps=50)
+
+  model = _OnnxMotionModel(actor, motion)
+  model.eval()
+
+  x = torch.randn(1, actor.obs_dim)
+  t = 17
+  time_step = torch.tensor([[t]], dtype=torch.float32)
+
+  with torch.no_grad():
+    _, joint_pos, joint_vel, body_pos, body_quat, body_lin_vel, body_ang_vel = model(
+      x, time_step
+    )
+
+  torch.testing.assert_close(joint_pos, motion.joint_pos[t : t + 1])
+  torch.testing.assert_close(joint_vel, motion.joint_vel[t : t + 1])
+  torch.testing.assert_close(body_pos, motion.body_pos_w[t : t + 1])
+  torch.testing.assert_close(body_quat, motion.body_quat_w[t : t + 1])
+  torch.testing.assert_close(body_lin_vel, motion.body_lin_vel_w[t : t + 1])
+  torch.testing.assert_close(body_ang_vel, motion.body_ang_vel_w[t : t + 1])
+
+
+def test_onnx_motion_model_clamps_out_of_bounds_time_step():
+  """_OnnxMotionModel clamps time_step beyond motion length to last frame."""
+
+  num_steps = 20
+  actor = _make_actor(obs_normalization=False)
+  motion = _MockMotion(num_steps=num_steps)
+
+  model = _OnnxMotionModel(actor, motion)
+  model.eval()
+
+  x = torch.randn(1, actor.obs_dim)
+  time_step = torch.tensor([[999]], dtype=torch.float32)
+
+  with torch.no_grad():
+    _, joint_pos, *_ = model(x, time_step)
+
+  torch.testing.assert_close(joint_pos, motion.joint_pos[num_steps - 1 : num_steps])
+
+
+def _make_logger_mock(is_wandb: bool) -> MagicMock:
+  """Mock an rsl-rl Logger, specced off a real (cheap, inert) instance.
+
+  Speccing off an instance rather than the class keeps the instance attributes,
+  so an attribute rsl-rl renames or drops fails the test instead of silently
+  resolving to a truthy mock.
+  """
+  logger = Logger(
+    log_dir=None,
+    cfg={"algorithm": {}},
+    env_cfg={},
+    num_envs=1,
+    is_distributed=False,
+    gpu_world_size=1,
+    gpu_global_rank=0,
+    device="cpu",
+  )
+  mock = MagicMock(spec=logger)
+  mock.writer = MagicMock(spec=WandbLogWriter) if is_wandb else MagicMock()
+  return mock
+
+
+@pytest.mark.parametrize(
+  ("runner_module", "runner_class"),
+  [
+    ("mjlab.tasks.velocity.rl.runner", "VelocityOnPolicyRunner"),
+    ("mjlab.tasks.manipulation.rl.runner", "ManipulationOnPolicyRunner"),
+  ],
+)
+def test_task_runner_uploads_onnx_for_wandb_logger(
+  runner_module, runner_class, monkeypatch, tmp_path
+):
+  """ONNX is uploaded to W&B when the logger's writer is a WandbLogWriter."""
+  import importlib
+
+  runner_mod = importlib.import_module(runner_module)
+  runner_cls = getattr(runner_mod, runner_class)
+  runner = runner_cls.__new__(runner_cls)
+  runner.cfg = {"upload_model": True}
+  runner.logger = _make_logger_mock(is_wandb=True)
+  runner.env = MagicMock()
+  runner.export_policy_to_onnx = MagicMock()
+
+  monkeypatch.setattr(MjlabOnPolicyRunner, "save", lambda *a, **kw: None)
+  monkeypatch.setattr(runner_mod, "get_base_metadata", lambda *a: {})
+  monkeypatch.setattr(runner_mod, "attach_metadata_to_onnx", lambda *a: None)
+
+  checkpoint = tmp_path / "run-dir" / "model_100.pt"
+  checkpoint.parent.mkdir()
+  checkpoint.touch()
+  onnx_path = checkpoint.parent / f"{checkpoint.parent.name}.onnx"
+
+  mock_run = MagicMock()
+  mock_run.name = "test-run"
+  with patch.object(runner_mod, "wandb") as mock_wandb:
+    mock_wandb.run = mock_run
+    runner.save(str(checkpoint))
+
+  mock_wandb.save.assert_called_once_with(
+    str(onnx_path), base_path=str(checkpoint.parent)
+  )
+
+
+def _make_tracking_runner_shell(registry_name, is_wandb, upload_model=True):
+  """Build a MotionTrackingOnPolicyRunner with all heavy parts mocked out."""
+  from mjlab.tasks.tracking.rl.runner import MotionTrackingOnPolicyRunner
+
+  runner = MotionTrackingOnPolicyRunner.__new__(MotionTrackingOnPolicyRunner)
+  runner.registry_name = registry_name
+  runner.cfg = {"upload_model": upload_model}
+  runner.logger = _make_logger_mock(is_wandb)
+
+  mock_motion_term = MagicMock()
+  mock_motion_term.cfg.anchor_body_name = "pelvis"
+  mock_motion_term.cfg.body_names = ["body1"]
+  runner.env = MagicMock()
+  runner.env.unwrapped.command_manager.get_term.return_value = mock_motion_term
+  return runner
+
+
+def test_tracking_runner_registers_artifact_for_wandb_logger(monkeypatch, tmp_path):
+  """use_artifact is called when the logger's writer is a WandbLogWriter."""
+  from mjlab.rl.runner import MjlabOnPolicyRunner
+  from mjlab.tasks.tracking.rl import runner as runner_mod
+
+  runner = _make_tracking_runner_shell("org/motions/motion:latest", is_wandb=True)
+
+  monkeypatch.setattr(MjlabOnPolicyRunner, "save", lambda *a, **kw: None)
+  monkeypatch.setattr(runner_mod, "get_base_metadata", lambda *a: {})
+  monkeypatch.setattr(runner_mod, "attach_metadata_to_onnx", lambda *a: None)
+  monkeypatch.setattr(
+    runner.env.unwrapped.__class__,
+    "export_policy_to_onnx",
+    lambda *a, **kw: None,
+    raising=False,
+  )
+
+  checkpoint = tmp_path / "run-dir" / "model_100.pt"
+  checkpoint.parent.mkdir()
+  checkpoint.touch()
+
+  mock_run = MagicMock()
+  mock_run.name = "test-run"
+
+  with patch.object(runner_mod, "wandb") as mock_wandb:
+    mock_wandb.run = mock_run
+    runner.export_policy_to_onnx = MagicMock()
+    runner.save(str(checkpoint))
+
+  mock_run.use_artifact.assert_called_once_with("org/motions/motion:latest")
+
+
+def test_tracking_runner_does_not_register_artifact_for_tensorboard(
+  monkeypatch, tmp_path
+):
+  """use_artifact is NOT called when using the tensorboard logger."""
+  from mjlab.rl.runner import MjlabOnPolicyRunner
+  from mjlab.tasks.tracking.rl import runner as runner_mod
+
+  runner = _make_tracking_runner_shell("org/motions/motion:latest", is_wandb=False)
+
+  monkeypatch.setattr(MjlabOnPolicyRunner, "save", lambda *a, **kw: None)
+  monkeypatch.setattr(runner_mod, "get_base_metadata", lambda *a: {})
+  monkeypatch.setattr(runner_mod, "attach_metadata_to_onnx", lambda *a: None)
+
+  checkpoint = tmp_path / "run-dir" / "model_100.pt"
+  checkpoint.parent.mkdir()
+  checkpoint.touch()
+
+  with patch.object(runner_mod, "wandb") as mock_wandb:
+    runner.export_policy_to_onnx = MagicMock()
+    runner.save(str(checkpoint))
+
+  mock_wandb.run.use_artifact.assert_not_called()
diff --git a/tests/test_scene.py b/tests/test_scene.py
new file mode 100644
index 0000000..bbba782
--- /dev/null
+++ b/tests/test_scene.py
@@ -0,0 +1,597 @@
+"""Tests for Scene class."""
+
+from unittest.mock import Mock
+
+import mujoco
+import mujoco_warp as mjwarp
+import pytest
+import torch
+from conftest import get_test_device, load_fixture_xml
+
+from mjlab.actuator import BuiltinPositionActuatorCfg
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.scene import Scene, SceneCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+from mjlab.sim.sim_data import WarpBridge
+
+# ============================================================================
+# Fixtures
+# ============================================================================
+
+
+@pytest.fixture
+def device():
+  """Test device fixture."""
+  return get_test_device()
+
+
+@pytest.fixture
+def simple_entity_xml():
+  """Simple entity XML for testing."""
+  return load_fixture_xml("fixed_base_box")
+
+
+@pytest.fixture
+def robot_entity_xml():
+  """Robot entity XML for testing."""
+  return """
+    <mujoco>
+      <worldbody>
+        <body name="base" pos="0 0 1">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="1.0"/>
+          <body name="link1" pos="0.3 0 0">
+            <joint name="joint1" type="hinge" axis="0 0 1" range="0 1.57"/>
+            <geom name="link1_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+          </body>
+        </body>
+      </worldbody>
+    </mujoco>
+    """
+
+
+@pytest.fixture
+def simple_entity_cfg(simple_entity_xml):
+  """Entity config for a simple box."""
+  return EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(simple_entity_xml))
+
+
+@pytest.fixture
+def robot_entity_cfg(robot_entity_xml):
+  """Entity config for a robot."""
+  return EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(robot_entity_xml))
+
+
+@pytest.fixture
+def minimal_scene_cfg():
+  """Minimal scene configuration."""
+  return SceneCfg(
+    num_envs=1,
+    env_spacing=2.0,
+  )
+
+
+@pytest.fixture
+def scene_with_entities_cfg(simple_entity_cfg, robot_entity_cfg):
+  """Scene configuration with multiple entities."""
+  return SceneCfg(
+    num_envs=4,
+    env_spacing=3.0,
+    entities={
+      "box": simple_entity_cfg,
+      "robot": robot_entity_cfg,
+    },
+  )
+
+
+@pytest.fixture
+def entity_with_site_xml():
+  """Entity XML with a site for tendon attachment."""
+  return """
+    <mujoco>
+      <worldbody>
+        <body name="box" pos="0 0 0.5">
+          <freejoint name="free"/>
+          <geom name="box_geom" type="box" size="0.1 0.1 0.1" mass="1.0"/>
+          <site name="hook" pos="0 0 0.1" size="0.01"/>
+        </body>
+      </worldbody>
+    </mujoco>
+    """
+
+
+@pytest.fixture
+def initialized_scene(scene_with_entities_cfg, device):
+  """Create an initialized scene with simulation."""
+  scene = Scene(scene_with_entities_cfg, device)
+  model = scene.compile()
+  data = mujoco.MjData(model)
+  mujoco.mj_resetData(model, data)
+
+  wp_model = mjwarp.put_model(model)
+  wp_data = mjwarp.put_data(model, data, nworld=scene.num_envs)
+  wp_model = WarpBridge(wp_model, nworld=scene.num_envs)
+  wp_data = WarpBridge(wp_data)
+
+  scene.initialize(model, wp_model, wp_data)  # type: ignore
+  return scene, wp_data
+
+
+@pytest.fixture
+def mock_entities():
+  """Create mock entities for testing."""
+  mock_box = Mock(spec=Entity)
+  mock_robot = Mock(spec=Entity)
+  return {"box": mock_box, "robot": mock_robot}
+
+
+# ============================================================================
+# Basic Scene Tests
+# ============================================================================
+
+
+def test_minimal_scene_creation(minimal_scene_cfg, device):
+  """Test creating a minimal scene with no entities."""
+  scene = Scene(minimal_scene_cfg, device)
+
+  assert scene.num_envs == 1
+  assert scene.env_spacing == 2.0
+  assert len(scene.entities) == 0
+  assert scene.terrain is None
+
+
+def test_scene_with_entities(scene_with_entities_cfg, device):
+  """Test creating a scene with multiple entities."""
+  scene = Scene(scene_with_entities_cfg, device)
+
+  assert scene.num_envs == 4
+  assert scene.env_spacing == 3.0
+  assert len(scene.entities) == 2
+  assert "box" in scene.entities
+  assert "robot" in scene.entities
+  assert isinstance(scene.entities["box"], Entity)
+  assert isinstance(scene.entities["robot"], Entity)
+
+
+# ============================================================================
+# Scene Compilation Tests
+# ============================================================================
+
+
+def test_compile_empty_scene(minimal_scene_cfg, device):
+  """Test compiling an empty scene."""
+  scene = Scene(minimal_scene_cfg, device=device)
+  model = scene.compile()
+
+  assert isinstance(model, mujoco.MjModel)
+  assert model.nbody == 1
+  assert model.nq == model.nv == 0
+
+
+def test_compile_scene_with_entities(scene_with_entities_cfg, device):
+  """Test compiling a scene with entities."""
+  scene = Scene(scene_with_entities_cfg, device)
+  model = scene.compile()
+
+  assert isinstance(model, mujoco.MjModel)
+  # Should have world + entity bodies.
+  assert model.nbody > 1
+  # Check that entity names are prefixed
+  body_names = [model.body(i).name for i in range(model.nbody)]
+  assert any("box/" in name for name in body_names)
+  assert any("robot/" in name for name in body_names)
+
+
+def test_write_zip(minimal_scene_cfg, tmp_path, device):
+  """Test exporting scene to zip file."""
+  scene = Scene(minimal_scene_cfg, device)
+  out = tmp_path / "scene_pkg"
+
+  scene.write(out, zip=True)
+  assert out.with_suffix(".zip").exists()
+
+
+def test_write_skips_unreferenced_assets(minimal_scene_cfg, tmp_path, device):
+  """write() only includes assets referenced in the generated XML."""
+  scene = Scene(minimal_scene_cfg, device)
+  scene._spec.assets["unused_mesh.stl"] = b"fake"
+  out = tmp_path / "out"
+  scene.write(out)
+  assert (out / "scene.xml").exists()
+  assets_dir = out / "assets"
+  asset_files = list(assets_dir.rglob("*")) if assets_dir.exists() else []
+  assert not any(f.is_file() for f in asset_files)
+
+
+def test_write_no_traversal_escape(minimal_scene_cfg, tmp_path, device):
+  """Asset keys with path traversal must not escape the output directory."""
+  scene = Scene(minimal_scene_cfg, device)
+  scene._spec.assets["../../assets/robot/mesh.stl"] = b"fake"
+  out = tmp_path / "subdir" / "out"
+  scene.write(out)
+  for f in tmp_path.rglob("*"):
+    if f.is_file() and f.name != "scene.xml":
+      assert str(f).startswith(str(out)), f"File escaped output dir: {f}"
+
+
+# ============================================================================
+# Entity Access Tests
+# ============================================================================
+
+
+def test_entity_dict_access(scene_with_entities_cfg, device):
+  """Test accessing entities through dictionary."""
+  scene = Scene(scene_with_entities_cfg, device)
+
+  box = scene.entities["box"]
+  robot = scene.entities["robot"]
+
+  assert isinstance(box, Entity)
+  assert isinstance(robot, Entity)
+  assert box.is_fixed_base
+  assert not robot.is_fixed_base
+
+
+def test_entity_getitem_access(scene_with_entities_cfg, device):
+  """Test accessing entities through __getitem__."""
+  scene = Scene(scene_with_entities_cfg, device)
+
+  box = scene["box"]
+  robot = scene["robot"]
+
+  assert isinstance(box, Entity)
+  assert isinstance(robot, Entity)
+
+
+def test_invalid_entity_access(scene_with_entities_cfg, device):
+  """Test accessing non-existent entity raises KeyError."""
+  scene = Scene(scene_with_entities_cfg, device)
+
+  with pytest.raises(KeyError, match="Scene element 'invalid' not found"):
+    _ = scene["invalid"]
+
+
+# ============================================================================
+# Scene Initialization Tests
+# ============================================================================
+
+
+def test_scene_initialize(initialized_scene, device):
+  """Test that scene initialization sets up entities."""
+  scene, _ = initialized_scene
+
+  # Check default env origins are set.
+  assert scene._default_env_origins is not None
+  assert scene._default_env_origins.shape == (4, 3)  # 4 envs, 3D positions.
+  assert scene._default_env_origins.device.type == device.split(":")[0]
+
+  # Check entities are initialized.
+  for entity in scene.entities.values():
+    assert hasattr(entity, "data")
+    assert entity.data is not None
+
+
+def test_env_origins_without_terrain(initialized_scene):
+  """Test env_origins property without terrain."""
+  scene, _ = initialized_scene
+
+  origins = scene.env_origins
+  assert origins.shape == (4, 3)
+  assert torch.all(origins == 0)  # Default origins should be zeros.
+
+
+# ============================================================================
+# Scene Operations Tests
+# ============================================================================
+
+
+def test_scene_reset(minimal_scene_cfg, mock_entities, device):
+  """Test that reset calls reset on all entities."""
+  scene = Scene(minimal_scene_cfg, device)
+  scene._entities = mock_entities
+
+  # Reset all environments
+  scene.reset()
+  for entity in mock_entities.values():
+    entity.reset.assert_called_once_with(None)
+
+  # Reset specific environments
+  for entity in mock_entities.values():
+    entity.reset.reset_mock()
+
+  env_ids = torch.tensor([0, 2])
+  scene.reset(env_ids)
+  for entity in mock_entities.values():
+    entity.reset.assert_called_once_with(env_ids)
+
+
+def test_scene_update(minimal_scene_cfg, mock_entities, device):
+  """Test that update calls update on all entities."""
+  scene = Scene(minimal_scene_cfg, device)
+  scene._entities = mock_entities
+
+  dt = 0.01
+  scene.update(dt)
+
+  for entity in mock_entities.values():
+    entity.update.assert_called_once_with(dt)
+
+
+def test_scene_write_data_to_sim(minimal_scene_cfg, mock_entities, device):
+  """Test that write_data_to_sim calls the method on all entities."""
+  scene = Scene(minimal_scene_cfg, device)
+  scene._entities = mock_entities
+
+  scene.write_data_to_sim()
+
+  for entity in mock_entities.values():
+    entity.write_data_to_sim.assert_called_once()
+
+
+# ============================================================================
+# Integration Tests
+# ============================================================================
+
+
+def test_full_scene_lifecycle(robot_entity_cfg, device, tmp_path):
+  """Test complete scene lifecycle from creation to simulation."""
+  scene_cfg = SceneCfg(
+    num_envs=3,
+    env_spacing=2.5,
+    entities={
+      "robot1": robot_entity_cfg,
+      "robot2": robot_entity_cfg,
+    },
+  )
+
+  scene = Scene(scene_cfg, device)
+
+  assert scene.num_envs == 3
+  assert len(scene.entities) == 2
+
+  model = scene.compile()
+  data = mujoco.MjData(model)
+  mujoco.mj_resetData(model, data)
+
+  wp_model = mjwarp.put_model(model)
+  wp_data = mjwarp.put_data(model, data, nworld=scene.num_envs)
+  wp_model = WarpBridge(wp_model, nworld=scene.num_envs)
+  wp_data = WarpBridge(wp_data)
+
+  scene.initialize(model, wp_model, wp_data)  # type: ignore
+
+  scene.reset()
+  scene.update(0.01)
+  scene.write_data_to_sim()
+
+  scene.reset(env_ids=torch.tensor([0, 2]))
+
+  out = tmp_path / "test_scene_pkg"
+  scene.write(out, zip=True)
+  assert out.with_suffix(".zip").exists()
+
+  for entity in scene.entities.values():
+    assert entity.data is not None
+    if not entity.is_fixed_base:
+      assert entity.data.root_link_pose_w.shape == (3, 7)
+
+
+# ============================================================================
+# Scene spec_fn Tests
+# ============================================================================
+
+
+def test_scene_spec_fn_adds_site(device):
+  """Test that spec_fn can add elements to the scene spec."""
+
+  def add_custom_site(spec: mujoco.MjSpec) -> None:
+    spec.worldbody.add_site(name="custom_site", pos=(1, 2, 3))
+
+  cfg = SceneCfg(spec_fn=add_custom_site)
+  scene = Scene(cfg, device)
+  model = scene.compile()
+
+  site_id = model.site("custom_site").id
+  assert site_id >= 0
+  assert tuple(model.site_pos[site_id]) == (1.0, 2.0, 3.0)
+
+
+def test_scene_spec_fn_cross_entity_tendon(entity_with_site_xml, device):
+  """Test that spec_fn can create tendons between two entities."""
+  entity_cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(entity_with_site_xml)
+  )
+
+  def add_tendon_between_entities(spec: mujoco.MjSpec) -> None:
+    # Add a world anchor site.
+    spec.worldbody.add_site(name="anchor", pos=(0, 0, 2), size=(0.01,) * 3)
+    # Create tendon from anchor to entity A.
+    tendon_a = spec.add_tendon(name="rope_a", width=0.005)
+    tendon_a.wrap_site("anchor")
+    tendon_a.wrap_site("entity_a/hook")
+    # Create tendon from anchor to entity B.
+    tendon_b = spec.add_tendon(name="rope_b", width=0.005)
+    tendon_b.wrap_site("anchor")
+    tendon_b.wrap_site("entity_b/hook")
+
+  cfg = SceneCfg(
+    entities={"entity_a": entity_cfg, "entity_b": entity_cfg},
+    spec_fn=add_tendon_between_entities,
+  )
+  scene = Scene(cfg, device)
+  model = scene.compile()
+
+  # Verify tendons exist.
+  assert model.tendon("rope_a").id >= 0
+  assert model.tendon("rope_b").id >= 0
+  # Verify sites are referenced correctly (2 wraps per tendon).
+  assert model.ntendon == 2
+  assert model.nwrap == 4
+
+
+# ============================================================================
+# Keyframe Merging Tests
+# ============================================================================
+
+
+@pytest.fixture
+def floating_box_cfg():
+  """Entity config for a floating box with initial position."""
+  xml = """
+    <mujoco>
+      <worldbody>
+        <body name="box">
+          <freejoint name="box_joint"/>
+          <geom type="box" size="0.1 0.1 0.1"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+  return EntityCfg(
+    init_state=EntityCfg.InitialStateCfg(pos=(1.0, 2.0, 3.0)),
+    spec_fn=lambda: mujoco.MjSpec.from_string(xml),
+  )
+
+
+@pytest.fixture
+def floating_sphere_cfg():
+  """Entity config for a floating sphere with initial position."""
+  xml = """
+    <mujoco>
+      <worldbody>
+        <body name="sphere">
+          <freejoint name="sphere_joint"/>
+          <geom type="sphere" size="0.1"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+  return EntityCfg(
+    init_state=EntityCfg.InitialStateCfg(pos=(4.0, 5.0, 6.0)),
+    spec_fn=lambda: mujoco.MjSpec.from_string(xml),
+  )
+
+
+def test_single_entity_keyframe(floating_box_cfg, device):
+  """Test that a single entity produces one merged keyframe."""
+  cfg = SceneCfg(entities={"box": floating_box_cfg})
+  scene = Scene(cfg, device)
+  model = scene.compile()
+
+  assert model.nkey == 1
+  assert model.key(0).name == "init_state"
+  # qpos: [x, y, z, qw, qx, qy, qz]
+  assert tuple(model.key(0).qpos[:3]) == (1.0, 2.0, 3.0)
+
+
+def test_multiple_entities_merged_keyframe(
+  floating_box_cfg, floating_sphere_cfg, device
+):
+  """Test that multiple entities produce a single merged keyframe."""
+  cfg = SceneCfg(entities={"box": floating_box_cfg, "sphere": floating_sphere_cfg})
+  scene = Scene(cfg, device)
+  model = scene.compile()
+
+  assert model.nkey == 1
+  assert model.key(0).name == "init_state"
+  # Box qpos (0-6), sphere qpos (7-13).
+  qpos = model.key(0).qpos
+  assert tuple(qpos[:3]) == (1.0, 2.0, 3.0)  # box position
+  assert tuple(qpos[7:10]) == (4.0, 5.0, 6.0)  # sphere position
+
+
+# ============================================================================
+# Multi-Entity Actuator Tests
+# ============================================================================
+
+
+def test_two_actuated_entities_write_ctrl(device):
+  """Test that two identical actuated entities write controls to the correct global positions."""
+
+  robot_xml = load_fixture_xml("floating_base_articulated")
+
+  entity_cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(robot_xml),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        BuiltinPositionActuatorCfg(
+          target_names_expr=("joint.*",),
+          effort_limit=100.0,
+          stiffness=80.0,
+          damping=10.0,
+        ),
+      )
+    ),
+  )
+
+  num_envs = 2
+  scene_cfg = SceneCfg(
+    num_envs=num_envs,
+    env_spacing=3.0,
+    entities={"robot_a": entity_cfg, "robot_b": entity_cfg},
+  )
+
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim = Simulation(num_envs=num_envs, cfg=SimulationCfg(), model=model, device=device)
+  scene.initialize(model, sim.model, sim.data)
+
+  robot_a = scene["robot_a"]
+  robot_b = scene["robot_b"]
+  assert isinstance(robot_a, Entity)
+  assert isinstance(robot_b, Entity)
+
+  # Set different position targets for each entity.
+  target_a = torch.tensor([[0.1, 0.2]], device=device).expand(num_envs, -1)
+  target_b = torch.tensor([[0.5, 0.6]], device=device).expand(num_envs, -1)
+
+  robot_a.set_joint_position_target(target_a)
+  robot_a.set_joint_velocity_target(torch.zeros(num_envs, 2, device=device))
+  robot_a.set_joint_effort_target(torch.zeros(num_envs, 2, device=device))
+
+  robot_b.set_joint_position_target(target_b)
+  robot_b.set_joint_velocity_target(torch.zeros(num_envs, 2, device=device))
+  robot_b.set_joint_effort_target(torch.zeros(num_envs, 2, device=device))
+
+  scene.write_data_to_sim()
+
+  # Verify that each entity's controls landed in the correct global ctrl positions.
+  global_ctrl_a = robot_a.indexing.ctrl_ids
+  global_ctrl_b = robot_b.indexing.ctrl_ids
+
+  # The two entities should have different global ctrl ranges.
+  assert not torch.equal(global_ctrl_a, global_ctrl_b)
+
+  # Check that the ctrl values in global positions match each entity's expected output.
+  ctrl_a = sim.data.ctrl[0, global_ctrl_a]
+  ctrl_b = sim.data.ctrl[0, global_ctrl_b]
+
+  # Controls should differ since targets differ.
+  assert not torch.allclose(ctrl_a, ctrl_b)
+
+
+def test_entity_with_option_flags_warns(device):
+  """Entity XML <option> flags are not propagated by MjSpec.attach()."""
+  xml_with_option = """
+    <mujoco>
+      <option>
+        <flag contact="disable" />
+      </option>
+      <worldbody>
+        <body name="box" pos="0 0 0.5">
+          <freejoint name="free"/>
+          <geom name="box_geom" type="box" size="0.1 0.1 0.1" mass="1.0"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+  cfg = SceneCfg(
+    num_envs=1,
+    entities={
+      "box": EntityCfg(
+        spec_fn=lambda: mujoco.MjSpec.from_string(xml_with_option),
+      ),
+    },
+  )
+  with pytest.warns(UserWarning, match="disableflags"):
+    Scene(cfg, device)
diff --git a/tests/test_scene_entity_config.py b/tests/test_scene_entity_config.py
new file mode 100644
index 0000000..18b2eff
--- /dev/null
+++ b/tests/test_scene_entity_config.py
@@ -0,0 +1,207 @@
+"""Unit tests for SceneEntityCfg resolution logic."""
+
+from dataclasses import dataclass
+
+import pytest
+
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+
+
+@dataclass
+class _FakeEntity:
+  name: str
+
+  joint_names: tuple[str, ...]
+  body_names: tuple[str, ...]
+  geom_names: tuple[str, ...]
+  site_names: tuple[str, ...]
+
+  @property
+  def num_joints(self) -> int:
+    return len(self.joint_names)
+
+  @property
+  def num_bodies(self) -> int:
+    return len(self.body_names)
+
+  @property
+  def num_geoms(self) -> int:
+    return len(self.geom_names)
+
+  @property
+  def num_sites(self) -> int:
+    return len(self.site_names)
+
+  # find_* helpers return (ids, names) similar to Entity API.
+  def _find(
+    self,
+    query_names: tuple[str, ...],
+    pool: tuple[str, ...],
+    preserve_order: bool,
+  ) -> tuple[list[int], list[str]]:
+    # Treat query as exact names (no regex) to keep tests minimal.
+    indices = [list(pool).index(n) for n in query_names]
+    if not preserve_order:
+      indices.sort()
+    names = [list(pool)[i] for i in indices]
+    return indices, names
+
+  def find_joints(self, query_names: tuple[str, ...], preserve_order: bool = False):
+    return self._find(query_names, self.joint_names, preserve_order)
+
+  def find_bodies(self, query_names: tuple[str, ...], preserve_order: bool = False):
+    return self._find(query_names, self.body_names, preserve_order)
+
+  def find_geoms(self, query_names: tuple[str, ...], preserve_order: bool = False):
+    return self._find(query_names, self.geom_names, preserve_order)
+
+  def find_sites(self, query_names: tuple[str, ...], preserve_order: bool = False):
+    return self._find(query_names, self.site_names, preserve_order)
+
+
+@pytest.fixture
+def fake_entity() -> _FakeEntity:
+  names = ("a", "b", "c")
+  return _FakeEntity(
+    name="robot",
+    joint_names=names,
+    body_names=names,
+    geom_names=names,
+    site_names=names,
+  )
+
+
+@pytest.fixture
+def fake_scene(fake_entity: _FakeEntity):
+  # Minimal scene-like mapping.
+  return {fake_entity.name: fake_entity}
+
+
+@pytest.mark.parametrize(
+  "field_names",
+  [
+    ("joint_names", "joint_ids"),
+    ("body_names", "body_ids"),
+    ("geom_names", "geom_ids"),
+    ("site_names", "site_ids"),
+  ],
+)
+def test_names_to_ids_sets_slice_when_all(fake_scene, fake_entity, field_names):
+  """Providing full set of names resolves ids and collapses to slice(None)."""
+  names_attr, ids_attr = field_names
+
+  cfg = SceneEntityCfg(name=fake_entity.name)
+  setattr(cfg, names_attr, getattr(fake_entity, names_attr))
+
+  cfg.resolve(fake_scene)
+
+  ids_value = getattr(cfg, ids_attr)
+  assert isinstance(ids_value, slice), f"{ids_attr} should collapse to slice(None)"
+  assert ids_value == slice(None)
+
+
+@pytest.mark.parametrize(
+  "field_names,ids",
+  [
+    (("joint_names", "joint_ids"), [0, 2]),
+    (("body_names", "body_ids"), [1]),
+    (("geom_names", "geom_ids"), [2, 0]),
+    (("site_names", "site_ids"), [1, 2]),
+  ],
+)
+def test_ids_to_names_resolves_names(fake_scene, fake_entity, field_names, ids):
+  """Providing explicit ids populates the corresponding names list."""
+  names_attr, ids_attr = field_names
+
+  cfg = SceneEntityCfg(name=fake_entity.name)
+  setattr(cfg, ids_attr, ids.copy())
+
+  cfg.resolve(fake_scene)
+
+  names_value = getattr(cfg, names_attr)
+  expected = [getattr(fake_entity, names_attr)[i] for i in ids]
+  assert names_value == expected
+
+
+@pytest.mark.parametrize(
+  "field_names,provided_names,provided_ids",
+  [
+    (("joint_names", "joint_ids"), ["a"], [1]),
+    (("body_names", "body_ids"), ["b"], [2]),
+    (("geom_names", "geom_ids"), ["c"], [0]),
+    (("site_names", "site_ids"), ["a"], [2]),
+  ],
+)
+def test_inconsistent_names_and_ids_raise(
+  fake_scene, field_names, provided_names, provided_ids
+):
+  """When both names and ids are provided but disagree, a ValueError is raised."""
+  names_attr, ids_attr = field_names
+
+  cfg = SceneEntityCfg(name="robot")
+  setattr(cfg, names_attr, provided_names.copy())
+  setattr(cfg, ids_attr, provided_ids.copy())  # Must be list to trigger check.
+
+  with pytest.raises(ValueError):
+    cfg.resolve(fake_scene)
+
+
+def test_tuple_names_with_consistent_ids(fake_scene):
+  """Tuple names with matching IDs should validate without error."""
+  cfg = SceneEntityCfg(name="robot")
+  cfg.joint_names = ("a", "b")
+  cfg.joint_ids = [0, 1]
+
+  cfg.resolve(fake_scene)
+
+  assert cfg.joint_names == ["a", "b"]
+  assert cfg.joint_ids == [0, 1]
+
+
+@pytest.mark.parametrize(
+  "field_names",
+  [
+    ("joint_names", "joint_ids"),
+    ("body_names", "body_ids"),
+    ("geom_names", "geom_ids"),
+    ("site_names", "site_ids"),
+  ],
+)
+def test_names_reordered_to_match_ids_when_not_preserving_order(
+  fake_scene, field_names
+):
+  """With preserve_order=False, names are reordered to internal order."""
+  names_attr, ids_attr = field_names
+
+  # Give a subset in reverse of internal order.
+  cfg = SceneEntityCfg(name="robot")
+  setattr(cfg, names_attr, ["c", "a"])
+
+  cfg.resolve(fake_scene)
+
+  # IDs and names must both be in internal order: a=0, c=2.
+  assert getattr(cfg, ids_attr) == [0, 2]
+  assert getattr(cfg, names_attr) == ["a", "c"]
+
+
+@pytest.mark.parametrize(
+  "field_names",
+  [
+    ("joint_names", "joint_ids"),
+    ("body_names", "body_ids"),
+    ("geom_names", "geom_ids"),
+    ("site_names", "site_ids"),
+  ],
+)
+def test_names_preserve_user_order_when_preserving_order(fake_scene, field_names):
+  """With preserve_order=True, names stay in the user-specified order."""
+  names_attr, ids_attr = field_names
+
+  cfg = SceneEntityCfg(name="robot", preserve_order=True)
+  setattr(cfg, names_attr, ["c", "a"])
+
+  cfg.resolve(fake_scene)
+
+  # User order preserved: c=2, a=0.
+  assert getattr(cfg, ids_attr) == [2, 0]
+  assert getattr(cfg, names_attr) == ["c", "a"]
diff --git a/tests/test_sensor_caching.py b/tests/test_sensor_caching.py
new file mode 100644
index 0000000..0265061
--- /dev/null
+++ b/tests/test_sensor_caching.py
@@ -0,0 +1,250 @@
+"""Tests for sensor caching behavior."""
+
+from __future__ import annotations
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.entity import EntityCfg
+from mjlab.scene import Scene, SceneCfg
+from mjlab.sensor import GridPatternCfg, ObjRef, RayCastSensorCfg
+from mjlab.sensor.contact_sensor import ContactMatch, ContactSensorCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+
+
+@pytest.fixture(scope="module")
+def device():
+  """Test device fixture."""
+  return get_test_device()
+
+
+FALLING_BOX_XML = """
+<mujoco>
+  <worldbody>
+    <body name="ground" pos="0 0 0">
+      <geom name="ground_geom" type="plane" size="5 5 0.1" rgba="0.5 0.5 0.5 1"/>
+    </body>
+    <body name="box" pos="0 0 0.5">
+      <freejoint name="box_joint"/>
+      <geom name="box_geom" type="box" size="0.1 0.1 0.1" rgba="0.8 0.3 0.3 1"
+        mass="1.0"/>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+
+ROBOT_WITH_FLOOR_XML = """
+<mujoco>
+  <worldbody>
+    <geom name="floor" type="plane" size="10 10 0.1" pos="0 0 0"/>
+    <body name="base" pos="0 0 2">
+      <freejoint name="free_joint"/>
+      <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="5.0"/>
+      <site name="base_site" pos="0 0 -0.1"/>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+
+
+def create_contact_sensor_scene(device: str, num_envs: int = 2):
+  """Create a scene with a contact sensor."""
+  entity_cfg = EntityCfg(spec_fn=lambda: mujoco.MjSpec.from_string(FALLING_BOX_XML))
+
+  contact_sensor_cfg = ContactSensorCfg(
+    name="box_contact",
+    primary=ContactMatch(mode="geom", pattern="box_geom", entity="box"),
+    secondary=None,
+    fields=("found", "force"),
+  )
+
+  scene_cfg = SceneCfg(
+    num_envs=num_envs,
+    env_spacing=3.0,
+    entities={"box": entity_cfg},
+    sensors=(contact_sensor_cfg,),
+  )
+
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim_cfg = SimulationCfg(njmax=75)
+  sim = Simulation(num_envs=num_envs, cfg=sim_cfg, model=model, device=device)
+  scene.initialize(sim.mj_model, sim.model, sim.data)
+
+  return scene, sim
+
+
+def create_raycast_sensor_scene(device: str, num_envs: int = 2):
+  """Create a scene with a raycast sensor."""
+  entity_cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_WITH_FLOOR_XML)
+  )
+
+  raycast_cfg = RayCastSensorCfg(
+    name="terrain_scan",
+    frame=ObjRef(type="body", name="base", entity="robot"),
+    pattern=GridPatternCfg(
+      size=(0.5, 0.5), resolution=0.25, direction=(0.0, 0.0, -1.0)
+    ),
+    max_distance=10.0,
+  )
+
+  scene_cfg = SceneCfg(
+    num_envs=num_envs,
+    env_spacing=5.0,
+    entities={"robot": entity_cfg},
+    sensors=(raycast_cfg,),
+  )
+
+  scene = Scene(scene_cfg, device)
+  model = scene.compile()
+  sim_cfg = SimulationCfg(njmax=20)
+  sim = Simulation(num_envs=num_envs, cfg=sim_cfg, model=model, device=device)
+  scene.initialize(sim.mj_model, sim.model, sim.data)
+  if scene.sensor_context is not None:
+    sim.set_sensor_context(scene.sensor_context)
+
+  return scene, sim
+
+
+def test_cache_invalidated_by_update(device):
+  """Verify that update() invalidates the cache."""
+  scene, sim = create_contact_sensor_scene(device)
+  sensor = scene["box_contact"]
+
+  sim.step()
+  scene.update(dt=sim.cfg.mujoco.timestep)
+
+  # Access data to populate cache.
+  data1 = sensor.data
+
+  # Call update to invalidate.
+  sensor.update(dt=sim.cfg.mujoco.timestep)
+
+  # Access data again - should be a new object.
+  data2 = sensor.data
+
+  # Should be different objects (cache was invalidated and recomputed).
+  assert data1 is not data2
+
+
+def test_cache_invalidated_by_reset(device):
+  """Verify that reset() invalidates the cache."""
+  scene, sim = create_contact_sensor_scene(device)
+  sensor = scene["box_contact"]
+
+  sim.step()
+  scene.update(dt=sim.cfg.mujoco.timestep)
+
+  # Access data to populate cache.
+  data1 = sensor.data
+
+  # Call reset to invalidate.
+  sensor.reset(None)
+
+  # Access data again - should be a new object.
+  data2 = sensor.data
+
+  # Should be different objects (cache was invalidated and recomputed).
+  assert data1 is not data2
+
+
+def test_compute_data_called_once_per_cache_period(device):
+  """Verify _compute_data is only called once when cache is valid."""
+  scene, sim = create_contact_sensor_scene(device)
+  sensor = scene["box_contact"]
+
+  sim.step()
+  scene.update(dt=sim.cfg.mujoco.timestep)
+
+  # Patch _compute_data to count calls.
+  original_compute = sensor._compute_data
+  call_count = [0]
+
+  def counting_compute():
+    call_count[0] += 1
+    return original_compute()
+
+  sensor._compute_data = counting_compute
+
+  # Access data 5 times without invalidating cache.
+  for _ in range(5):
+    _ = sensor.data
+
+  # _compute_data should have been called only once.
+  assert call_count[0] == 1
+
+
+def test_data_reflects_physics_after_step_and_update(device):
+  """Verify sensor data reflects physics state after step + update cycle."""
+  scene, sim = create_raycast_sensor_scene(device)
+  sensor = scene["terrain_scan"]
+  robot_entity = scene["robot"]
+
+  # Initial position at z=2.
+  sim.step()
+  scene.update(dt=sim.cfg.mujoco.timestep)
+  sim.sense()
+  data1 = sensor.data
+
+  # All rays should hit floor ~2m away.
+  assert torch.allclose(
+    data1.distances, torch.full_like(data1.distances, 2.0), atol=0.1
+  )
+
+  # Move robot higher.
+  root_state = torch.zeros((2, 13), device=device)
+  root_state[:, 2] = 4.0  # Move to z=4.
+  root_state[:, 3] = 1.0  # Unit quaternion.
+  robot_entity.write_root_state_to_sim(root_state)
+
+  sim.step()
+  scene.update(dt=sim.cfg.mujoco.timestep)
+  sim.sense()
+
+  data2 = sensor.data
+
+  # Now rays should hit floor ~4m away.
+  assert torch.allclose(
+    data2.distances, torch.full_like(data2.distances, 4.0), atol=0.1
+  )
+
+  # Data objects should be different (cache was invalidated).
+  assert data1 is not data2
+
+
+def test_stale_cache_without_update(device):
+  """Verify that without update(), cache returns stale data."""
+  scene, sim = create_raycast_sensor_scene(device)
+  sensor = scene["terrain_scan"]
+  robot_entity = scene["robot"]
+
+  # Initial step + update.
+  sim.step()
+  scene.update(dt=sim.cfg.mujoco.timestep)
+  sim.sense()
+
+  # Access data to populate cache.
+  data1 = sensor.data
+  initial_distances = data1.distances.clone()
+
+  # Move robot higher.
+  root_state = torch.zeros((2, 13), device=device)
+  root_state[:, 2] = 4.0  # Move to z=4.
+  root_state[:, 3] = 1.0  # Unit quaternion.
+  robot_entity.write_root_state_to_sim(root_state)
+
+  # Step but DON'T call update - cache should NOT be invalidated.
+  sim.step()
+
+  # Access data - should still be cached (stale).
+  data2 = sensor.data
+
+  # Data should be the same object (cache was not invalidated).
+  assert data1 is data2
+
+  # Values should be the same (stale).
+  assert torch.allclose(data2.distances, initial_distances)
diff --git a/tests/test_sim.py b/tests/test_sim.py
new file mode 100644
index 0000000..1f32b64
--- /dev/null
+++ b/tests/test_sim.py
@@ -0,0 +1,188 @@
+"""Tests for sim.py."""
+
+import mujoco
+import mujoco_warp as mjwarp
+import numpy as np
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.sim import MujocoCfg, Simulation, SimulationCfg
+
+
+@pytest.fixture
+def device():
+  """Test device fixture."""
+  return get_test_device()
+
+
+@pytest.fixture
+def robot_xml():
+  """Simple robot with geoms and joints."""
+  return """
+    <mujoco>
+      <worldbody>
+        <body name="base" pos="0 0 1">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="box" size="0.1 0.1 0.1" mass="1.0"
+            friction="0.5 0.01 0.005"/>
+          <body name="foot1" pos="0.2 0 0">
+            <joint name="joint1" type="hinge" axis="0 0 1" range="0 1.57"/>
+            <geom name="foot1_geom" type="box" size="0.05 0.05 0.05" mass="0.1"
+              friction="0.5 0.01 0.005"/>
+          </body>
+          <body name="foot2" pos="-0.2 0 0">
+            <joint name="joint2" type="hinge" axis="0 0 1" range="0 1.57"/>
+            <geom name="foot2_geom" type="box" size="0.05 0.05 0.05" mass="0.1"
+              friction="0.5 0.01 0.005"/>
+          </body>
+        </body>
+      </worldbody>
+    </mujoco>
+    """
+
+
+def test_simulation_config_is_piped(robot_xml, device):
+  """Test that SimulationCfg values are applied to both mj_model and wp_model."""
+  model = mujoco.MjModel.from_xml_string(robot_xml)
+
+  cfg = SimulationCfg(
+    contact_sensor_maxmatch=128,
+    broadphase="sap_tile",
+    broadphase_filter=("plane", "aabb"),
+    mujoco=MujocoCfg(
+      timestep=0.02,
+      integrator="euler",
+      solver="cg",
+      iterations=7,
+      ls_iterations=14,
+      ccd_iterations=20,
+      gravity=(0, 0, 7.5),
+      enableflags=("energy",),
+    ),
+  )
+
+  sim = Simulation(num_envs=1, cfg=cfg, model=model, device=device)
+
+  # MujocoCfg should be applied to mj_model.
+  assert sim.mj_model.opt.timestep == cfg.mujoco.timestep
+  assert sim.mj_model.opt.integrator == mujoco.mjtIntegrator.mjINT_EULER
+  assert sim.mj_model.opt.solver == mujoco.mjtSolver.mjSOL_CG
+  assert sim.mj_model.opt.iterations == cfg.mujoco.iterations
+  assert sim.mj_model.opt.ls_iterations == cfg.mujoco.ls_iterations
+  assert sim.mj_model.opt.ccd_iterations == cfg.mujoco.ccd_iterations
+  assert tuple(sim.mj_model.opt.gravity) == cfg.mujoco.gravity
+  assert sim.mj_model.opt.enableflags & mujoco.mjtEnableBit.mjENBL_ENERGY
+
+  # MujocoCfg should be inherited by wp_model via put_model.
+  np.testing.assert_almost_equal(
+    sim.model.opt.timestep[0].cpu().numpy(), cfg.mujoco.timestep
+  )
+  np.testing.assert_almost_equal(
+    sim.model.opt.gravity[0].cpu().numpy(), cfg.mujoco.gravity
+  )
+  assert sim.model.opt.integrator == mujoco.mjtIntegrator.mjINT_EULER
+  assert sim.model.opt.solver == mujoco.mjtSolver.mjSOL_CG
+  assert sim.model.opt.iterations == cfg.mujoco.iterations
+  assert sim.model.opt.enableflags & mujoco.mjtEnableBit.mjENBL_ENERGY
+
+  # SimulationCfg's warp-only settings should be applied to wp_model.opt.
+  assert sim.wp_model.opt.contact_sensor_maxmatch == cfg.contact_sensor_maxmatch
+  assert sim.wp_model.opt.broadphase == mjwarp.BroadphaseType.SAP_TILE
+  assert sim.wp_model.opt.broadphase_filter == (
+    mjwarp.BroadphaseFilter.PLANE | mjwarp.BroadphaseFilter.AABB
+  )
+
+
+def test_default_broadphase_keeps_put_model_heuristic(robot_xml, device):
+  """Unset broadphase settings should not override put_model's own heuristic."""
+  model = mujoco.MjModel.from_xml_string(robot_xml)
+  heuristic_opt = mjwarp.put_model(model).opt
+
+  sim = Simulation(num_envs=1, cfg=SimulationCfg(), model=model, device=device)
+
+  assert sim.wp_model.opt.broadphase == heuristic_opt.broadphase
+  assert sim.wp_model.opt.broadphase_filter == heuristic_opt.broadphase_filter
+
+
+def test_ls_parallel_is_deprecated():
+  """Setting the removed ls_parallel option warns instead of erroring."""
+  with pytest.warns(DeprecationWarning, match="ls_parallel"):
+    SimulationCfg(ls_parallel=True)
+
+
+def test_sim_reset_restores_initial_state(robot_xml, device):
+  """Test that sim.reset() restores qpos/qvel to initial values."""
+  model = mujoco.MjModel.from_xml_string(robot_xml)
+  sim = Simulation(num_envs=2, cfg=SimulationCfg(), model=model, device=device)
+
+  qpos0 = sim.data.qpos.clone()
+  qvel0 = sim.data.qvel.clone()
+
+  # Run simulation to modify state.
+  for _ in range(10):
+    sim.step()
+
+  assert not torch.allclose(sim.data.qpos, qpos0)
+  assert not torch.allclose(sim.data.qvel, qvel0)
+
+  # Reset should restore initial state.
+  sim.reset()
+
+  torch.testing.assert_close(sim.data.qpos[:], qpos0)
+  torch.testing.assert_close(sim.data.qvel[:], qvel0)
+  # qacc_warmstart should be zeroed.
+  assert (sim.data.qacc_warmstart == 0).all()
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="Likely bug on CPU MjWarp")
+def test_sim_reset_selective(robot_xml, device):
+  """Test that sim.reset() only affects specified environments."""
+  model = mujoco.MjModel.from_xml_string(robot_xml)
+  sim = Simulation(num_envs=4, cfg=SimulationCfg(), model=model, device=device)
+
+  qpos0 = sim.data.qpos.clone()
+
+  # Run simulation to modify state.
+  for _ in range(10):
+    sim.step()
+
+  qpos_after_sim = sim.data.qpos.clone()
+
+  # Reset only env 1 and 3.
+  sim.reset(torch.tensor([1, 3], device=device))
+
+  # Envs 1 and 3 should be reset.
+  torch.testing.assert_close(sim.data.qpos[1], qpos0[1])
+  torch.testing.assert_close(sim.data.qpos[3], qpos0[3])
+  # Envs 0 and 2 should be unchanged.
+  torch.testing.assert_close(sim.data.qpos[0], qpos_after_sim[0])
+  torch.testing.assert_close(sim.data.qpos[2], qpos_after_sim[2])
+
+
+def test_xpos_matches_qpos_after_forward(robot_xml, device):
+  """sim.step() leaves xpos stale; sim.forward() makes it match qpos.
+
+  In MuJoCo, mj_step = mj_step1 (forward kinematics + forces) + mj_step2
+  (integration). After mj_step, qpos/qvel are post-integration but xpos is
+  from the pre-integration forward pass. sim.forward() recomputes xpos from
+  the current qpos.
+  """
+  model = mujoco.MjModel.from_xml_string(robot_xml)
+  cfg = SimulationCfg(mujoco=MujocoCfg(timestep=0.01))  # Large dt for clear signal
+  sim = Simulation(num_envs=2, cfg=cfg, model=model, device=device)
+
+  # Step enough for significant velocity -> large staleness gap.
+  for _ in range(50):
+    sim.step()
+
+  # xpos is stale: reflects pre-integration state of last step.
+  # For the freejoint body (body 1), qpos[:3] is the true position.
+  xpos_stale = sim.data.xpos[:, 1].clone()
+  qpos_pos = sim.data.qpos[:, :3].clone()
+  assert not torch.allclose(xpos_stale, qpos_pos, atol=1e-4)
+
+  # forward() refreshes derived quantities from current qpos.
+  sim.forward()
+  xpos_fresh = sim.data.xpos[:, 1].clone()
+  torch.testing.assert_close(xpos_fresh, qpos_pos, atol=1e-5, rtol=0)
diff --git a/tests/test_sim_data.py b/tests/test_sim_data.py
new file mode 100644
index 0000000..0f1685c
--- /dev/null
+++ b/tests/test_sim_data.py
@@ -0,0 +1,100 @@
+"""Tests for sim data bridge."""
+
+from dataclasses import dataclass
+
+import pytest
+import torch
+import warp as wp
+from conftest import get_test_device
+
+from mjlab.sim.sim_data import TorchArray, WarpBridge
+
+
+@dataclass
+class MockData:
+  arr: wp.array
+  val: float = 1.0
+
+
+@pytest.fixture
+def device():
+  """Test device fixture."""
+  return get_test_device()
+
+
+@pytest.fixture
+def mock_data(device):
+  with wp.ScopedDevice(device):
+    return MockData(arr=wp.array([[1.0, 2.0], [3.0, 4.0]], dtype=wp.float32))
+
+
+def test_torch_array_shares_memory(device):
+  """TorchArray modifications affect underlying warp array."""
+  with wp.ScopedDevice(device):
+    wp_arr = wp.array([1.0, 2.0], dtype=wp.float32)
+  torch_arr = TorchArray(wp_arr)
+  torch_arr[0] = 99.0
+  assert wp_arr.numpy()[0] == 99.0
+
+
+def test_torch_array_ops_work(device):
+  """TorchArray supports PyTorch operations."""
+  with wp.ScopedDevice(device):
+    wp_arr = wp.array([1.0, 2.0], dtype=wp.float32)
+  torch_arr = TorchArray(wp_arr)
+  assert torch.allclose(torch_arr * 2, torch.tensor([2.0, 4.0], device=device))
+  assert torch.sum(torch_arr).item() == 3.0  # type: ignore
+
+
+def test_torch_array_expands_batched_singleton_world_dim(device):
+  """Size-1 world dim expands to nworld when mjwarp marks the array batched."""
+  with wp.ScopedDevice(device):
+    wp_arr = wp.array([[1.0, 2.0]], dtype=wp.float32)
+  setattr(wp_arr, "_is_batched", True)  # noqa: B010
+  torch_arr = TorchArray(wp_arr, nworld=4)
+  assert torch_arr.shape == (4, 2)
+
+
+def test_torch_array_keeps_unbatched_singleton_dim(device):
+  """A real size-1 leading dim without the batched marker is not expanded."""
+  with wp.ScopedDevice(device):
+    wp_arr = wp.array([[1.0, 2.0]], dtype=wp.float32)
+  torch_arr = TorchArray(wp_arr, nworld=4)
+  assert torch_arr.shape == (1, 2)
+
+
+def test_bridge_wraps_arrays(mock_data):
+  """WarpBridge wraps warp arrays as TorchArray."""
+  bridge = WarpBridge(mock_data)
+  assert isinstance(bridge.arr, TorchArray)
+  assert bridge.val == 1.0  # Non-arrays pass through.
+
+
+def test_bridge_preserves_memory_on_slice_assign(mock_data, device):
+  """Slice assignment preserves memory addresses (CUDA graph safe)."""
+  bridge = WarpBridge(mock_data)
+  initial_ptr = bridge.arr._tensor.data_ptr()
+
+  bridge.arr[:] = torch.zeros((2, 2), device=device)
+
+  assert bridge.arr._tensor.data_ptr() == initial_ptr
+  assert torch.all(bridge.arr._tensor == 0)
+
+
+def test_bridge_raises_on_setattr(mock_data, device):
+  """Direct assignment raises AttributeError with helpful message."""
+  bridge = WarpBridge(mock_data)
+
+  with pytest.raises(AttributeError, match="Cannot set attribute 'arr' on WarpBridge"):
+    bridge.arr = torch.zeros((2, 2), device=device)
+
+  with pytest.raises(AttributeError, match="Use in-place operations instead"):
+    bridge.val = 42.0
+
+
+def test_bridge_caches_wrappers(mock_data):
+  """WarpBridge caches wrapper objects."""
+  bridge = WarpBridge(mock_data)
+  arr1 = bridge.arr
+  arr2 = bridge.arr
+  assert arr1 is arr2  # Same cached object.
diff --git a/tests/test_spec_config.py b/tests/test_spec_config.py
new file mode 100644
index 0000000..49d053b
--- /dev/null
+++ b/tests/test_spec_config.py
@@ -0,0 +1,622 @@
+"""Tests for spec_config.py."""
+
+import math
+from typing import cast
+
+import mujoco
+import pytest
+
+from mjlab.utils.spec_config import (
+  CameraCfg,
+  CollisionCfg,
+  GeomCfg,
+  LightCfg,
+  MaterialCfg,
+  MeshCfg,
+  TextureCfg,
+)
+
+
+@pytest.fixture
+def simple_robot_xml():
+  """Minimal robot XML for testing."""
+  return """
+    <mujoco>
+      <worldbody>
+        <body name="base" pos="0 0 1">
+          <freejoint name="free_joint"/>
+          <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="1.0"/>
+          <body name="link1" pos="0 0 0">
+            <joint name="joint1" type="hinge" axis="0 0 1" range="0 1.57"/>
+            <geom name="link1_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+          </body>
+          <body name="link2" pos="0 0 0">
+            <joint name="joint2" type="hinge" axis="0 0 1" range="0 1.57"/>
+            <geom name="link2_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+          </body>
+        </body>
+      </worldbody>
+    </mujoco>
+    """
+
+
+# Collision Tests
+
+
+@pytest.fixture
+def multi_geom_spec():
+  """Spec with multiple geoms for collision testing."""
+  spec = mujoco.MjSpec()
+  body = spec.worldbody.add_body(name="test_body")
+  body.add_geom(
+    name="left_foot1_collision", type=mujoco.mjtGeom.mjGEOM_BOX, size=[0.1, 0.1, 0.1]
+  )
+  body.add_geom(
+    name="right_foot3_collision", type=mujoco.mjtGeom.mjGEOM_BOX, size=[0.1, 0.1, 0.1]
+  )
+  body.add_geom(
+    name="arm_collision", type=mujoco.mjtGeom.mjGEOM_BOX, size=[0.1, 0.1, 0.1]
+  )
+  return spec
+
+
+def test_collision_basic_properties(multi_geom_spec):
+  """CollisionCfg should set basic collision properties."""
+  collision_cfg = CollisionCfg(
+    geom_names_expr=("arm_collision",), contype=2, conaffinity=3, condim=4, priority=1
+  )
+  collision_cfg.edit_spec(multi_geom_spec)
+
+  geom = multi_geom_spec.geom("arm_collision")
+  assert geom.contype == 2
+  assert geom.conaffinity == 3
+  assert geom.condim == 4
+  assert geom.priority == 1
+
+
+def test_collision_regex_matching(multi_geom_spec):
+  """CollisionCfg should support regex pattern matching."""
+  collision_cfg = CollisionCfg(
+    geom_names_expr=(r"^(left|right)_foot\d_collision$",),
+    contype=1,
+    conaffinity=1,
+    condim=3,
+    priority=1,
+    friction=(0.6,),
+    disable_other_geoms=False,
+  )
+  collision_cfg.edit_spec(multi_geom_spec)
+
+  left_foot = multi_geom_spec.geom("left_foot1_collision")
+  assert left_foot.condim == 3
+  assert left_foot.priority == 1
+  assert left_foot.friction[0] == 0.6
+
+  right_foot = multi_geom_spec.geom("right_foot3_collision")
+  assert right_foot.condim == 3
+
+  arm = multi_geom_spec.geom("arm_collision")
+  assert arm.condim == 3  # Default unchanged.
+
+
+def test_collision_dict_field_resolution(multi_geom_spec):
+  """CollisionCfg should support dict-based field resolution."""
+  collision_cfg = CollisionCfg(
+    geom_names_expr=(r".*_foot\d_collision$", "arm_collision"),
+    contype=1,
+    conaffinity=1,
+    condim={r".*_foot\d_collision$": 3, "arm_collision": 1},
+    priority={r".*_foot\d_collision$": 2, "arm_collision": 0},
+  )
+  collision_cfg.edit_spec(multi_geom_spec)
+
+  left_foot = multi_geom_spec.geom("left_foot1_collision")
+  assert left_foot.condim == 3
+  assert left_foot.priority == 2
+
+  arm = multi_geom_spec.geom("arm_collision")
+  assert arm.condim == 1
+  assert arm.priority == 0
+
+
+def test_collision_margin_gap_solmix(multi_geom_spec):
+  """CollisionCfg should set margin, gap, and solmix on matched geoms."""
+  collision_cfg = CollisionCfg(
+    geom_names_expr=("arm_collision",),
+    contype=1,
+    conaffinity=1,
+    condim=3,
+    priority=0,
+    margin=0.01,
+    gap=0.005,
+    solmix=0.5,
+    disable_other_geoms=False,
+  )
+  collision_cfg.edit_spec(multi_geom_spec)
+
+  geom = multi_geom_spec.geom("arm_collision")
+  assert geom.margin == pytest.approx(0.01)
+  assert geom.gap == pytest.approx(0.005)
+  assert geom.solmix == pytest.approx(0.5)
+
+
+def test_collision_margin_gap_solmix_dict(multi_geom_spec):
+  """CollisionCfg should support dict-based margin, gap, solmix overrides."""
+  collision_cfg = CollisionCfg(
+    geom_names_expr=(r".*_foot\d_collision$", "arm_collision"),
+    contype=1,
+    conaffinity=1,
+    condim=3,
+    priority=0,
+    margin={r".*_foot\d_collision$": 0.02, "arm_collision": 0.01},
+    gap={r".*_foot\d_collision$": 0.01, "arm_collision": 0.0},
+    solmix={r".*_foot\d_collision$": 0.8, "arm_collision": 0.2},
+    disable_other_geoms=False,
+  )
+  collision_cfg.edit_spec(multi_geom_spec)
+
+  left_foot = multi_geom_spec.geom("left_foot1_collision")
+  assert left_foot.margin == pytest.approx(0.02)
+  assert left_foot.gap == pytest.approx(0.01)
+  assert left_foot.solmix == pytest.approx(0.8)
+
+  arm = multi_geom_spec.geom("arm_collision")
+  assert arm.margin == pytest.approx(0.01)
+  assert arm.solmix == pytest.approx(0.2)
+
+
+def test_collision_structural_dict_requires_coverage(multi_geom_spec):
+  """Dict-valued structural fields must cover every matched geom."""
+  collision_cfg = CollisionCfg(
+    geom_names_expr=(".*_collision",),
+    contype=1,
+    conaffinity=1,
+    condim={r".*_foot\d_collision$": 3},  # Does not cover arm_collision.
+    priority=0,
+  )
+  with pytest.raises(ValueError, match="condim dict does not match geom"):
+    collision_cfg.edit_spec(multi_geom_spec)
+
+
+def test_collision_structural_fields_are_required():
+  """Structural fields cannot be None."""
+  cfg = CollisionCfg(
+    geom_names_expr=(".*",),
+    contype=1,
+    conaffinity=1,
+    condim=cast(int, None),
+    priority=0,
+  )
+  with pytest.raises(ValueError, match="condim is required"):
+    cfg.validate()
+
+
+def test_collision_disable_other_geoms(multi_geom_spec):
+  """CollisionCfg should disable non-matching geoms when requested."""
+  collision_cfg = CollisionCfg(
+    geom_names_expr=("left_foot1_collision",),
+    contype=2,
+    conaffinity=1,
+    condim=3,
+    priority=0,
+    disable_other_geoms=True,
+  )
+  collision_cfg.edit_spec(multi_geom_spec)
+
+  left_foot = multi_geom_spec.geom("left_foot1_collision")
+  assert left_foot.contype == 2
+
+  right_foot = multi_geom_spec.geom("right_foot3_collision")
+  assert right_foot.contype == 0
+  assert right_foot.conaffinity == 0
+
+  arm = multi_geom_spec.geom("arm_collision")
+  assert arm.contype == 0
+
+
+# fmt: off
+@pytest.mark.parametrize(
+  "param,value,expected_error",
+  [
+    ("condim", -1, "condim must be one of"),
+    ("condim", 2, "condim must be one of"),
+    ("contype", -1, "contype must be non-negative"),
+    ("conaffinity", -1, "conaffinity must be non-negative"),
+    ("priority", -1, "priority must be non-negative"),
+    ("margin", -0.1, "margin must be non-negative"),
+    ("gap", -0.1, "gap must be non-negative"),
+    ("solmix", 1.5, r"solmix must be in \[0, 1\]"),
+  ],
+)
+# fmt: on
+def test_collision_validation(param, value, expected_error):
+  """CollisionCfg should validate parameters."""
+  with pytest.raises(ValueError, match=expected_error):
+    cfg = CollisionCfg(
+      geom_names_expr=("test",),
+      contype=value if param == "contype" else 1,
+      conaffinity=value if param == "conaffinity" else 1,
+      condim=value if param == "condim" else 3,
+      priority=value if param == "priority" else 0,
+      margin=value if param == "margin" else None,
+      gap=value if param == "gap" else None,
+      solmix=value if param == "solmix" else None,
+    )
+    cfg.validate()
+
+
+# Mesh Tests
+
+
+def _sphere_points(n: int) -> list[float]:
+  """Deterministic point cloud on a unit sphere (Fibonacci lattice).
+
+  Every point is on the hull, so the unconstrained hull has n vertices.
+  """
+  phi = math.pi * (3.0 - math.sqrt(5.0))
+  verts: list[float] = []
+  for i in range(n):
+    y = 1.0 - 2.0 * (i + 0.5) / n
+    r = math.sqrt(max(0.0, 1.0 - y * y))
+    theta = phi * i
+    verts += [math.cos(theta) * r, y, math.sin(theta) * r]
+  return verts
+
+
+@pytest.fixture
+def multi_mesh_spec():
+  """Spec with two mesh assets, each a 100-vertex sphere point cloud."""
+  spec = mujoco.MjSpec()
+  for name in ("blob_a", "blob_b"):
+    mesh = spec.add_mesh()
+    mesh.name = name
+    mesh.uservert = _sphere_points(100)
+  return spec
+
+
+def _hull_numvert(spec: mujoco.MjSpec, mesh_name: str) -> int:
+  """Compile and return the convex-hull vertex count for a mesh asset.
+
+  maxhullvert caps the hull stored in mesh_graph (which the narrowphase support
+  function walks), not the raw mesh_vert array, so we read it back from the
+  compiled graph: the first int at mesh_graphadr is the hull vertex count.
+  """
+  body = spec.worldbody.add_body()
+  geom = body.add_geom()
+  geom.type = mujoco.mjtGeom.mjGEOM_MESH
+  geom.meshname = mesh_name
+  model = spec.compile()
+  mesh_id = model.mesh(mesh_name).id
+  return int(model.mesh_graph[model.mesh_graphadr[mesh_id]])
+
+
+def test_mesh_maxhullvert_scalar(multi_mesh_spec):
+  """MeshCfg should set maxhullvert on every matched mesh asset."""
+  MeshCfg(mesh_names_expr=(".*",), maxhullvert=12).edit_spec(multi_mesh_spec)
+
+  assert multi_mesh_spec.mesh("blob_a").maxhullvert == 12
+  assert multi_mesh_spec.mesh("blob_b").maxhullvert == 12
+
+
+def test_mesh_maxhullvert_regex_matching(multi_mesh_spec):
+  """Only meshes matching the regex should be modified; others stay default."""
+  MeshCfg(mesh_names_expr=("blob_a",), maxhullvert=8).edit_spec(multi_mesh_spec)
+
+  assert multi_mesh_spec.mesh("blob_a").maxhullvert == 8
+  assert multi_mesh_spec.mesh("blob_b").maxhullvert == -1  # Unchanged default.
+
+
+def test_mesh_maxhullvert_dict_resolution(multi_mesh_spec):
+  """A dict should resolve per-mesh values by pattern."""
+  MeshCfg(
+    mesh_names_expr=(".*",),
+    maxhullvert={"blob_a": 6, "blob_b": 20},
+  ).edit_spec(multi_mesh_spec)
+
+  assert multi_mesh_spec.mesh("blob_a").maxhullvert == 6
+  assert multi_mesh_spec.mesh("blob_b").maxhullvert == 20
+
+
+def test_mesh_unconstrained_hull_keeps_all_vertices(multi_mesh_spec):
+  """Baseline: without a cap, every sphere point is a hull vertex."""
+  assert _hull_numvert(multi_mesh_spec, "blob_a") == 100
+
+
+def test_mesh_maxhullvert_caps_compiled_hull(multi_mesh_spec):
+  """The cap should actually shrink the compiled convex hull below the baseline."""
+  MeshCfg(mesh_names_expr=("blob_a",), maxhullvert=10).edit_spec(multi_mesh_spec)
+  assert _hull_numvert(multi_mesh_spec, "blob_a") == 10
+
+
+@pytest.mark.parametrize("value", [0, 2, 3, -2])
+def test_mesh_maxhullvert_validation(value):
+  """maxhullvert must be -1 or greater than 3."""
+  with pytest.raises(ValueError, match="maxhullvert must be"):
+    MeshCfg(mesh_names_expr=(".*",), maxhullvert=value).validate()
+
+
+def test_mesh_maxhullvert_dict_validation():
+  """Validation should also cover dict-valued maxhullvert."""
+  with pytest.raises(ValueError, match="maxhullvert must be.*pattern 'blob_a'"):
+    MeshCfg(mesh_names_expr=(".*",), maxhullvert={"blob_a": 2}).validate()
+
+
+def test_mesh_maxhullvert_allows_unlimited():
+  """-1 (unlimited) is valid and is the MuJoCo default."""
+  MeshCfg(mesh_names_expr=(".*",), maxhullvert=-1).validate()
+
+
+# Visual Element Tests
+
+
+def test_texture_cfg():
+  """TextureCfg should add textures to spec."""
+  spec = mujoco.MjSpec()
+  texture_cfg = TextureCfg(
+    name="test_texture",
+    type="2d",
+    builtin="checker",
+    rgb1=(1.0, 0.0, 0.0),
+    rgb2=(0.0, 1.0, 0.0),
+    width=64,
+    height=64,
+  )
+  texture_cfg.edit_spec(spec)
+
+  texture = spec.texture("test_texture")
+  assert texture.name == "test_texture"
+
+
+def test_texture_cfg_image_fields():
+  """TextureCfg should set file, grid, nchannel, flip, and random fields."""
+  spec = mujoco.MjSpec()
+  texture_cfg = TextureCfg(
+    name="test_texture",
+    type="cube",
+    mark="random",
+    random=0.25,
+    file="sky.png",
+    gridsize=(3, 4),
+    gridlayout=".U..LFRB.D..",
+    nchannel=4,
+    hflip=True,
+    vflip=True,
+  )
+  texture_cfg.edit_spec(spec)
+
+  texture = spec.texture("test_texture")
+  assert texture.file == "sky.png"
+  assert tuple(texture.gridsize) == (3, 4)
+  assert texture.nchannel == 4
+  assert texture.hflip
+  assert texture.vflip
+  assert texture.random == pytest.approx(0.25)
+
+
+@pytest.mark.parametrize(
+  "param,value,expected_error",
+  [
+    ("width", 0, "width must be positive"),
+    ("width", -1, "width must be positive"),
+    ("height", 0, "height must be positive"),
+    ("height", -1, "height must be positive"),
+  ],
+)
+def test_texture_cfg_validation(param, value, expected_error):
+  """TextureCfg should validate explicitly set width and height."""
+  with pytest.raises(ValueError, match=expected_error):
+    TextureCfg(
+      name="test_texture",
+      type="2d",
+      builtin="checker",
+      width=value if param == "width" else 64,
+      height=value if param == "height" else 64,
+    ).validate()
+
+
+def test_texture_requires_source():
+  """A texture with no builtin, file, or cubefiles has nothing to render."""
+  with pytest.raises(ValueError, match="must specify a builtin pattern"):
+    TextureCfg(name="test_texture", type="2d").validate()
+
+
+@pytest.mark.parametrize("gridsize", [None, (1, 1)])
+def test_texture_single_file_skybox_validation(gridsize):
+  """A single-image skybox cannot be sampled as six faces by the Warp renderer."""
+  with pytest.raises(ValueError, match="must declare a gridsize"):
+    TextureCfg(
+      name="sky", type="skybox", file="sky.png", gridsize=gridsize
+    ).validate()
+
+
+def test_texture_skybox_allows_grid_and_cubefiles():
+  """A larger grid or explicit cubefiles cover all six faces."""
+  TextureCfg(name="sky", type="skybox", file="sky.png", gridsize=(6, 1)).validate()
+  TextureCfg(
+    name="sky", type="skybox", cubefiles=("a", "b", "c", "d", "e", "f")
+  ).validate()
+
+
+def test_texture_skybox_builtin_overrides_single_file():
+  """A builtin pattern takes precedence over the file, so the grid is irrelevant."""
+  TextureCfg(
+    name="sky", type="skybox", builtin="gradient", file="sky.png"
+  ).validate()
+
+
+def test_material_cfg():
+  """MaterialCfg should add materials to spec."""
+  spec = mujoco.MjSpec()
+  material_cfg = MaterialCfg(
+    name="test_material",
+    texuniform=True,
+    texrepeat=(2, 2),
+    reflectance=0.5,
+  )
+  material_cfg.edit_spec(spec)
+
+  material = spec.material("test_material")
+  assert material.name == "test_material"
+
+
+def test_light_cfg():
+  """LightCfg should add lights to spec."""
+  spec = mujoco.MjSpec()
+  light_cfg = LightCfg(
+    name="test_light",
+    body="world",
+    type="spot",
+    pos=(1.0, 2.0, 3.0),
+    dir=(0.0, 0.0, -1.0),
+  )
+  light_cfg.edit_spec(spec)
+
+  light = spec.light("test_light")
+  assert light.name == "test_light"
+
+
+def test_light_cfg_color_and_attenuation():
+  """LightCfg should set diffuse, specular, ambient, active, attenuation."""
+  spec = mujoco.MjSpec()
+  light_cfg = LightCfg(
+    name="test_light",
+    diffuse=(1.0, 0.0, 0.0),
+    specular=(0.0, 1.0, 0.0),
+    ambient=(0.0, 0.0, 1.0),
+    active=False,
+    attenuation=(1.0, 0.5, 0.25),
+  )
+  light_cfg.edit_spec(spec)
+
+  light = spec.light("test_light")
+  assert tuple(light.diffuse) == pytest.approx((1.0, 0.0, 0.0))
+  assert tuple(light.specular) == pytest.approx((0.0, 1.0, 0.0))
+  assert tuple(light.ambient) == pytest.approx((0.0, 0.0, 1.0))
+  assert not light.active
+  assert tuple(light.attenuation) == pytest.approx((1.0, 0.5, 0.25))
+
+
+def test_camera_cfg():
+  """CameraCfg should add cameras to spec."""
+  spec = mujoco.MjSpec()
+  camera_cfg = CameraCfg(
+    name="test_camera", body="world", fovy=60.0, pos=(0.0, 0.0, 5.0)
+  )
+  camera_cfg.edit_spec(spec)
+
+  camera = spec.camera("test_camera")
+  assert camera.name == "test_camera"
+
+
+def test_material_cfg_geom_assignment():
+  """MaterialCfg.geom_names_expr assigns material to matching geoms."""
+  spec = mujoco.MjSpec()
+  body = spec.worldbody.add_body(name="test_body")
+  body.add_geom(
+    name="link1_visual",
+    type=mujoco.mjtGeom.mjGEOM_BOX,
+    size=[0.1, 0.1, 0.1],
+  )
+  body.add_geom(
+    name="link2_visual",
+    type=mujoco.mjtGeom.mjGEOM_BOX,
+    size=[0.1, 0.1, 0.1],
+  )
+  body.add_geom(
+    name="arm_collision",
+    type=mujoco.mjtGeom.mjGEOM_BOX,
+    size=[0.1, 0.1, 0.1],
+  )
+
+  mat_cfg = MaterialCfg(
+    name="my_mat",
+    texuniform=True,
+    texrepeat=(1, 1),
+    geom_names_expr=(r".*_visual$",),
+  )
+  mat_cfg.edit_spec(spec)
+
+  assert spec.geom("link1_visual").material == "my_mat"
+  assert spec.geom("link2_visual").material == "my_mat"
+  assert spec.geom("arm_collision").material == ""
+
+
+def test_geom_group_basic(multi_geom_spec):
+  """GeomCfg should set the group of matching geoms."""
+  group_cfg = GeomCfg(
+    geom_names_expr=(r"^(left|right)_foot\d_collision$",), group=3
+  )
+  group_cfg.edit_spec(multi_geom_spec)
+
+  assert multi_geom_spec.geom("left_foot1_collision").group == 3
+  assert multi_geom_spec.geom("right_foot3_collision").group == 3
+
+  arm = multi_geom_spec.geom("arm_collision")
+  assert arm.group == 0  # Default unchanged.
+
+
+def test_geom_group_none_is_noop(multi_geom_spec):
+  """GeomCfg should leave the group alone when it is None."""
+  multi_geom_spec.geom("arm_collision").group = 2
+  GeomCfg(geom_names_expr=(".*",)).edit_spec(multi_geom_spec)
+
+  assert multi_geom_spec.geom("arm_collision").group == 2
+
+
+def test_geom_group_dict_field_resolution(multi_geom_spec):
+  """GeomCfg should support dict-based field resolution."""
+  group_cfg = GeomCfg(
+    geom_names_expr=(r".*_foot\d_collision$", "arm_collision"),
+    group={r".*_foot\d_collision$": 3, "arm_collision": 4},
+  )
+  group_cfg.edit_spec(multi_geom_spec)
+
+  assert multi_geom_spec.geom("left_foot1_collision").group == 3
+  assert multi_geom_spec.geom("arm_collision").group == 4
+
+
+def test_geom_group_unnamed_geoms():
+  """GeomCfg should update every matching geom, including unnamed ones."""
+  spec = mujoco.MjSpec()
+  body = spec.worldbody.add_body(name="test_body")
+  for _ in range(3):
+    body.add_geom(type=mujoco.mjtGeom.mjGEOM_BOX, size=[0.1, 0.1, 0.1])
+
+  group_cfg = GeomCfg(geom_names_expr=(".*",), group=3)
+  group_cfg.edit_spec(spec)
+
+  assert [g.group for g in spec.geoms] == [3, 3, 3]
+
+
+@pytest.mark.parametrize("value", [-1, mujoco.mjNGROUP, {"arm_collision": -1}])
+def test_geom_group_validation(value):
+  """GeomCfg should validate the group."""
+  with pytest.raises(ValueError, match="group must be in"):
+    cfg = GeomCfg(geom_names_expr=("test",), group=value)
+    cfg.validate()
+
+
+def test_geom_patches_collision_attrs(multi_geom_spec):
+  """GeomCfg should patch collision attributes, leaving unset ones alone."""
+  multi_geom_spec.geom("left_foot1_collision").contype = 2
+  GeomCfg(
+    geom_names_expr=(r"^(left|right)_foot\d_collision$",),
+    condim=6,
+    friction=(1.0, 5e-3, 5e-4),
+  ).edit_spec(multi_geom_spec)
+
+  left_foot = multi_geom_spec.geom("left_foot1_collision")
+  assert left_foot.condim == 6
+  assert left_foot.friction[0] == pytest.approx(1.0)
+  assert left_foot.contype == 2  # Unset attribute untouched.
+
+  arm = multi_geom_spec.geom("arm_collision")
+  assert arm.condim == 3  # Unmatched geom untouched.
+
+
+def test_geom_collision_attr_validation():
+  """GeomCfg should validate collision attributes like CollisionCfg does."""
+  with pytest.raises(ValueError, match="condim must be one of"):
+    GeomCfg(geom_names_expr=("test",), condim=2).validate()
+  with pytest.raises(ValueError, match="solmix must be in"):
+    GeomCfg(geom_names_expr=("test",), solmix=1.5).validate()
diff --git a/tests/test_spec_utils.py b/tests/test_spec_utils.py
new file mode 100644
index 0000000..83dc4d4
--- /dev/null
+++ b/tests/test_spec_utils.py
@@ -0,0 +1,214 @@
+"""Tests for spec.py utilities."""
+
+import mujoco
+import numpy as np
+import pytest
+
+from mjlab.utils.spec import create_position_actuator, create_velocity_actuator
+
+
+@pytest.fixture
+def spec_with_limited_joint():
+  """Create a spec with a limited joint for testing."""
+  spec = mujoco.MjSpec()
+  body = spec.worldbody.add_body(name="test_body")
+  joint = body.add_joint(
+    name="test_joint",
+    type=mujoco.mjtJoint.mjJNT_SLIDE,
+    axis=[0, 0, 1],
+    range=[-1.0, 1.0],
+  )
+  joint.limited = mujoco.mjtLimited.mjLIMITED_TRUE
+  body.add_geom(type=mujoco.mjtGeom.mjGEOM_BOX, size=[0.1, 0.1, 0.1], mass=1.0)
+  return spec
+
+
+def test_position_actuator_allows_setpoints_beyond_joint_limits(
+  spec_with_limited_joint,
+):
+  """Verify that position actuators allow commanding setpoints beyond joint limits.
+
+  This is the core fix: position actuators have ctrllimited=False, allowing
+  policies to command positions outside kinematic limits to maximize torque.
+  We verify this by comparing torque when commanding beyond vs at the limit.
+  """
+  stiffness = 100.0
+  create_position_actuator(
+    spec_with_limited_joint,
+    "test_joint",
+    stiffness=stiffness,
+    damping=10.0,
+    effort_limit=500.0,
+  )
+  model = spec_with_limited_joint.compile()
+  data = mujoco.MjData(model)
+
+  # Verify ctrllimited=False.
+  actuator_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_ACTUATOR, "test_joint")
+  assert model.actuator_ctrllimited[actuator_id] == 0
+
+  # Set joint position.
+  current_pos = 0.5
+  data.qpos[0] = current_pos
+  data.qvel[0] = 0.0
+
+  # Command beyond joint upper limit (1.0).
+  target_beyond = 2.0
+  data.ctrl[0] = target_beyond
+  mujoco.mj_forward(model, data)
+  torque_beyond = data.actuator_force[0]
+
+  # Expected: -kp * (q - target) = -100 * (0.5 - 2.0) = 150.0.
+  expected_torque_beyond = -stiffness * (current_pos - target_beyond)
+  np.testing.assert_allclose(torque_beyond, expected_torque_beyond, rtol=1e-5)
+
+  # If control were clipped to limit (1.0), torque would be 50.0.
+  expected_if_clipped = -stiffness * (current_pos - 1.0)
+  assert abs(torque_beyond) == 3.0 * abs(expected_if_clipped)
+
+
+def test_position_actuator_forces_clipped_to_effort_limit(spec_with_limited_joint):
+  """Verify that actuator forces are clipped to effort_limit, not control limits.
+
+  While control setpoints aren't clipped, forces must still be limited to
+  prevent unrealistic torques.
+  """
+  effort_limit = 10.0
+  stiffness = 1000.0
+  create_position_actuator(
+    spec_with_limited_joint,
+    "test_joint",
+    stiffness=stiffness,
+    damping=1.0,
+    effort_limit=effort_limit,
+  )
+  model = spec_with_limited_joint.compile()
+  data = mujoco.MjData(model)
+
+  # Verify forcelimited=True.
+  actuator_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_ACTUATOR, "test_joint")
+  assert model.actuator_forcelimited[actuator_id] == 1
+  np.testing.assert_array_almost_equal(
+    model.actuator_forcerange[actuator_id], [-effort_limit, effort_limit]
+  )
+
+  # Large position error would generate force > effort_limit without clipping.
+  data.qpos[0] = 0.0
+  data.ctrl[0] = 3.0
+  mujoco.mj_step(model, data)
+
+  # Force should saturate at effort_limit.
+  assert abs(data.actuator_force[0]) <= effort_limit + 1e-6
+  assert abs(data.actuator_force[0]) >= effort_limit - 1e-3
+
+
+def test_ctrllimited_true_would_clip_internally():
+  """Demonstrate that ctrllimited=True clips control internally (the bug).
+
+  This test shows what would happen with the bug: commanding at vs beyond
+  the limit generates identical forces, proving internal clipping.
+  """
+  spec = mujoco.MjSpec()
+  body = spec.worldbody.add_body(name="test_body")
+  joint = body.add_joint(
+    name="test_joint",
+    type=mujoco.mjtJoint.mjJNT_SLIDE,
+    axis=[0, 0, 1],
+    range=[-1.0, 1.0],
+  )
+  joint.limited = mujoco.mjtLimited.mjLIMITED_TRUE
+  body.add_geom(type=mujoco.mjtGeom.mjGEOM_BOX, size=[0.1, 0.1, 0.1], mass=1.0)
+
+  # Manually create actuator WITH THE BUG: ctrllimited=True.
+  stiffness = 100.0
+  actuator = spec.add_actuator(name="test_joint", target="test_joint")
+  actuator.trntype = mujoco.mjtTrn.mjTRN_JOINT
+  actuator.dyntype = mujoco.mjtDyn.mjDYN_NONE
+  actuator.gaintype = mujoco.mjtGain.mjGAIN_FIXED
+  actuator.biastype = mujoco.mjtBias.mjBIAS_AFFINE
+  actuator.ctrllimited = True  # THE BUG.
+  actuator.ctrlrange[:] = np.array([-1.0, 1.0])
+  actuator.gainprm[0] = stiffness
+  actuator.biasprm[1] = -stiffness
+  actuator.biasprm[2] = -10.0
+
+  model = spec.compile()
+  data = mujoco.MjData(model)
+
+  data.qpos[0] = 0.5
+  data.qvel[0] = 0.0
+
+  # Command at limit.
+  data.ctrl[0] = 1.0
+  mujoco.mj_forward(model, data)
+  force_at_limit = data.actuator_force[0]
+
+  # Command beyond limit.
+  data.ctrl[0] = 2.0
+  mujoco.mj_forward(model, data)
+  force_beyond = data.actuator_force[0]
+
+  # With the bug, forces are IDENTICAL (both clipped to 1.0 internally).
+  np.testing.assert_allclose(force_beyond, force_at_limit, rtol=1e-10)
+  expected_force = -stiffness * (0.5 - 1.0)
+  np.testing.assert_allclose(force_at_limit, expected_force, rtol=1e-5)
+
+
+@pytest.fixture
+def spec_with_continuous_joint():
+  """Create a spec with a continuous (unlimited) hinge joint."""
+  spec = mujoco.MjSpec()
+  body = spec.worldbody.add_body(name="wheel")
+  body.add_joint(
+    name="wheel_joint",
+    type=mujoco.mjtJoint.mjJNT_HINGE,
+    axis=[0, 0, 1],
+  )
+  body.add_geom(type=mujoco.mjtGeom.mjGEOM_CYLINDER, size=[0.1, 0.05], mass=1.0)
+  return spec
+
+
+def test_velocity_actuator_continuous_joint(spec_with_continuous_joint):
+  """Velocity actuator compiles for continuous joints with no range."""
+  damping = 10.0
+  create_velocity_actuator(
+    spec_with_continuous_joint,
+    "wheel_joint",
+    damping=damping,
+  )
+  model = spec_with_continuous_joint.compile()
+  data = mujoco.MjData(model)
+
+  actuator_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_ACTUATOR, "wheel_joint")
+  assert model.actuator_ctrllimited[actuator_id] == 0
+
+  # Commanding a velocity target should produce force = damping * (ctrl - qvel).
+  data.qvel[0] = 0.0
+  data.ctrl[0] = 5.0
+  mujoco.mj_forward(model, data)
+  expected_force = damping * 5.0
+  np.testing.assert_allclose(data.actuator_force[0], expected_force, rtol=1e-5)
+
+
+def test_velocity_actuator_forces_clipped_to_effort_limit(
+  spec_with_continuous_joint,
+):
+  """Velocity actuator force is bounded by effort_limit."""
+  effort_limit = 20.0
+  create_velocity_actuator(
+    spec_with_continuous_joint,
+    "wheel_joint",
+    damping=1000.0,
+    effort_limit=effort_limit,
+  )
+  model = spec_with_continuous_joint.compile()
+  data = mujoco.MjData(model)
+
+  actuator_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_ACTUATOR, "wheel_joint")
+  assert model.actuator_forcelimited[actuator_id] == 1
+
+  # Large velocity error would exceed effort_limit without clamping.
+  data.qvel[0] = 0.0
+  data.ctrl[0] = 100.0
+  mujoco.mj_forward(model, data)
+  assert abs(data.actuator_force[0]) <= effort_limit + 1e-6
diff --git a/tests/test_task_configs.py b/tests/test_task_configs.py
new file mode 100644
index 0000000..adee2fa
--- /dev/null
+++ b/tests/test_task_configs.py
@@ -0,0 +1,144 @@
+"""Generic tests for task config integrity."""
+
+import pytest
+
+from mjlab.envs import ManagerBasedRlEnvCfg
+from mjlab.managers.observation_manager import ObservationGroupCfg
+from mjlab.tasks.registry import list_tasks, load_env_cfg
+
+
+@pytest.fixture(scope="module")
+def all_task_ids() -> list[str]:
+  """Get all registered task IDs."""
+  return list_tasks()
+
+
+def test_all_tasks_loadable(all_task_ids: list[str]) -> None:
+  """All registered tasks should be loadable without errors."""
+  for task_id in all_task_ids:
+    try:
+      cfg = load_env_cfg(task_id)
+      assert isinstance(cfg, ManagerBasedRlEnvCfg), (
+        f"Task {task_id} did not return ManagerBasedRlEnvCfg"
+      )
+    except Exception as e:
+      pytest.fail(f"Failed to load task '{task_id}': {e}")
+
+
+def test_all_tasks_have_play_config(all_task_ids: list[str]) -> None:
+  """All tasks should be loadable in play mode."""
+  for task_id in all_task_ids:
+    try:
+      cfg = load_env_cfg(task_id, play=True)
+      assert isinstance(cfg, ManagerBasedRlEnvCfg), (
+        f"Task {task_id} play mode did not return ManagerBasedRlEnvCfg"
+      )
+    except Exception as e:
+      pytest.fail(f"Failed to load task '{task_id}' in play mode: {e}")
+
+
+def test_play_mode_episode_length(all_task_ids: list[str]) -> None:
+  """Play mode tasks should have infinite episode length."""
+  for task_id in all_task_ids:
+    cfg = load_env_cfg(task_id, play=True)
+    assert cfg.episode_length_s >= 1e9, (
+      f"{task_id} (play mode) episode_length_s={cfg.episode_length_s}, expected >= 1e9"
+    )
+
+
+def test_play_mode_observation_corruption_disabled(all_task_ids: list[str]) -> None:
+  """Play mode tasks should have observation corruption disabled for policy."""
+  for task_id in all_task_ids:
+    cfg = load_env_cfg(task_id, play=True)
+
+    assert "actor" in cfg.observations, (
+      f"Play mode task {task_id} missing 'policy' observation group"
+    )
+
+    policy_obs = cfg.observations["actor"]
+    assert isinstance(policy_obs, ObservationGroupCfg), (
+      f"Play mode task {task_id} policy observation is not ObservationGroupCfg"
+    )
+
+    assert not policy_obs.enable_corruption, (
+      f"Play mode task {task_id} has enable_corruption=True, expected False"
+    )
+
+
+def test_training_mode_observation_corruption_enabled(all_task_ids: list[str]) -> None:
+  """Training mode tasks should have observation corruption enabled for policy."""
+  for task_id in all_task_ids:
+    cfg = load_env_cfg(task_id)
+
+    assert "actor" in cfg.observations, (
+      f"Training task {task_id} missing 'policy' observation group"
+    )
+
+    policy_obs = cfg.observations["actor"]
+    assert isinstance(policy_obs, ObservationGroupCfg), (
+      f"Training task {task_id} policy observation is not ObservationGroupCfg"
+    )
+
+    assert policy_obs.enable_corruption, (
+      f"Training task {task_id} has enable_corruption=False, expected True"
+    )
+
+
+def test_critic_observation_corruption_always_disabled(all_task_ids: list[str]) -> None:
+  """Critic observations should always have corruption disabled."""
+  for task_id in all_task_ids:
+    cfg = load_env_cfg(task_id)
+
+    if "critic" not in cfg.observations:
+      continue
+
+    critic_obs = cfg.observations["critic"]
+    assert isinstance(critic_obs, ObservationGroupCfg), (
+      f"Task {task_id} critic observation is not ObservationGroupCfg"
+    )
+
+    assert not critic_obs.enable_corruption, (
+      f"Task {task_id} has critic enable_corruption=True, expected False"
+    )
+
+
+def test_play_training_observation_structure_match(all_task_ids: list[str]) -> None:
+  """Play and training configs should have matching observation structure."""
+  for task_id in all_task_ids:
+    training_cfg = load_env_cfg(task_id)
+    play_cfg = load_env_cfg(task_id, play=True)
+
+    # Same observation groups.
+    assert set(training_cfg.observations.keys()) == set(play_cfg.observations.keys()), (
+      f"Observation groups mismatch between {task_id} training and play modes"
+    )
+
+    # Same observation terms within each group.
+    for obs_group_name in training_cfg.observations:
+      training_terms = set(training_cfg.observations[obs_group_name].terms.keys())
+      play_terms = set(play_cfg.observations[obs_group_name].terms.keys())
+
+      assert training_terms == play_terms, (
+        f"Observation terms mismatch in group '{obs_group_name}' "
+        f"between {task_id} training and play modes"
+      )
+
+
+def test_play_training_action_structure_match(all_task_ids: list[str]) -> None:
+  """Play and training configs should have matching action structure."""
+  for task_id in all_task_ids:
+    training_cfg = load_env_cfg(task_id)
+    play_cfg = load_env_cfg(task_id, play=True)
+
+    assert set(training_cfg.actions.keys()) == set(play_cfg.actions.keys()), (
+      f"Action structure mismatch between {task_id} training and play modes"
+    )
+
+
+def test_play_mode_disables_push_robot(all_task_ids: list[str]) -> None:
+  """Play mode tasks should disable push_robot event."""
+  for task_id in all_task_ids:
+    cfg = load_env_cfg(task_id, play=True)
+    assert "push_robot" not in cfg.events, (
+      f"Play mode task {task_id} has push_robot event, expected it to be removed"
+    )
diff --git a/tests/test_terminations.py b/tests/test_terminations.py
new file mode 100644
index 0000000..223b4cc
--- /dev/null
+++ b/tests/test_terminations.py
@@ -0,0 +1,240 @@
+"""Tests for MDP termination functions."""
+
+from unittest.mock import Mock
+
+import mujoco
+import pytest
+import torch
+from conftest import get_test_device
+
+from mjlab.envs.mdp.terminations import nan_detection
+from mjlab.managers.termination_manager import TerminationManager, TerminationTermCfg
+from mjlab.sim.sim import Simulation, SimulationCfg
+from mjlab.tasks.velocity.mdp.terminations import (
+  out_of_terrain_bounds,
+  terrain_edge_reached,
+)
+
+
+@pytest.fixture
+def simple_model():
+  xml = """
+  <mujoco>
+    <worldbody>
+      <body>
+        <freejoint/>
+        <geom type="box" size="0.1 0.1 0.1"/>
+      </body>
+    </worldbody>
+  </mujoco>
+  """
+  return mujoco.MjModel.from_xml_string(xml)
+
+
+@pytest.fixture
+def mock_env_with_sim(simple_model):
+  env = Mock()
+  env.num_envs = 4
+  env.device = get_test_device()
+  env.episode_length_buf = torch.zeros(4, dtype=torch.long, device=env.device)
+  env.max_episode_length = 1000
+  env.sim = Simulation(
+    num_envs=env.num_envs, cfg=SimulationCfg(), model=simple_model, device=env.device
+  )
+  return env
+
+
+def test_nan_detection_function(mock_env_with_sim):
+  """Test that nan_detection correctly identifies NaN/Inf environments."""
+  env = mock_env_with_sim
+
+  # No NaNs initially.
+  result = nan_detection(env)
+  assert result.shape == (4,)
+  assert not result.any()
+
+  # Inject NaN in qpos for env 1.
+  env.sim.data.qpos[1, 0] = float("nan")
+  result = nan_detection(env)
+  assert result[1] and not result[0] and not result[2] and not result[3]
+
+  # Inject Inf in qacc_warmstart for env 3.
+  env.sim.data.qacc_warmstart[3, 0] = float("-inf")
+  result = nan_detection(env)
+  assert result[1] and result[3] and not result[0] and not result[2]
+
+
+def test_nan_detection_with_termination_manager(mock_env_with_sim):
+  """Test that nan_detection is properly logged by termination manager."""
+  env = mock_env_with_sim
+
+  cfg = {
+    "nan_term": TerminationTermCfg(func=nan_detection, params={}, time_out=False),
+  }
+
+  manager = TerminationManager(cfg, env)
+
+  # No terminations initially.
+  result = manager.compute()
+  assert not result.any()
+  assert not manager.terminated.any()
+  assert not manager.time_outs.any()
+
+  # Inject NaN in env 1.
+  env.sim.data.qpos[1, 0] = float("nan")
+
+  # Should detect termination in env 1.
+  result = manager.compute()
+  assert result[1] and not result[0] and not result[2] and not result[3]
+  assert manager.terminated[1]
+  assert not manager.time_outs[1]
+
+  # Reset should log the termination.
+  reset_info = manager.reset(torch.tensor([1], device=env.device))
+  assert "Episode_Termination/nan_term" in reset_info
+  assert reset_info["Episode_Termination/nan_term"] == 1
+
+  # Inject Inf in multiple envs.
+  env.sim.data.qvel[0, 0] = float("inf")
+  env.sim.data.qacc[2, 0] = float("-inf")
+
+  result = manager.compute()
+  assert result[0] and result[2]
+
+  # Reset should log multiple terminations.
+  reset_info = manager.reset(torch.tensor([0, 2], device=env.device))
+  assert reset_info["Episode_Termination/nan_term"] == 2
+
+
+@pytest.fixture
+def mock_env():
+  """Minimal mock environment for shape validation tests."""
+  env = Mock()
+  env.num_envs = 4
+  env.device = "cpu"
+  env.scene = {"robot": Mock()}
+  return env
+
+
+def test_termination_shape_validation_rejects_bad_compute_output(mock_env):
+  """Termination terms must return one boolean per environment."""
+  cfg = {
+    "bad": TerminationTermCfg(
+      func=lambda env: torch.zeros(env.num_envs, 1, dtype=torch.bool)
+    )
+  }
+  manager = TerminationManager(cfg, mock_env)
+  with pytest.raises(
+    ValueError, match="TerminationManager term 'bad'.*expected \\(4,\\)"
+  ):
+    manager.compute()
+
+
+@pytest.fixture
+def mock_terrain_env():
+  device = get_test_device()
+  num_envs = 4
+
+  env = Mock()
+  env.num_envs = num_envs
+  env.device = device
+  env.episode_length_buf = torch.full((num_envs,), 10, dtype=torch.long, device=device)
+
+  # Terrain with 8x8m sub-terrains.
+  terrain = Mock()
+  terrain.cfg.terrain_type = "generator"
+  terrain.cfg.terrain_generator.size = (8.0, 8.0)
+
+  env.scene.terrain = terrain
+  env.scene.env_origins = torch.zeros(num_envs, 3, device=device)
+
+  # Robot at spawn origin.
+  asset = Mock()
+  asset.data.root_link_pos_w = torch.zeros(num_envs, 3, device=device)
+  env.scene.__getitem__ = Mock(return_value=asset)
+
+  return env, asset
+
+
+def test_terrain_edge_reached_within_bounds(mock_terrain_env):
+  env, asset = mock_terrain_env
+  result = terrain_edge_reached(env, threshold_fraction=0.95)
+  assert not result.any()
+
+
+def test_terrain_edge_reached_at_edge(mock_terrain_env):
+  env, asset = mock_terrain_env
+  # Move env 1 past 95% of half-size (4.0 * 0.95 = 3.8m).
+  asset.data.root_link_pos_w[1, 0] = 3.9
+  result = terrain_edge_reached(env, threshold_fraction=0.95)
+  assert result[1] and not result[0] and not result[2] and not result[3]
+
+
+def test_terrain_edge_reached_skips_early_steps(mock_terrain_env):
+  env, asset = mock_terrain_env
+  asset.data.root_link_pos_w[0, 0] = 5.0
+  env.episode_length_buf[:] = 1  # Too early.
+  result = terrain_edge_reached(env, threshold_fraction=0.95)
+  assert not result.any()
+
+
+def test_terrain_edge_reached_no_terrain(mock_terrain_env):
+  env, asset = mock_terrain_env
+  env.scene.terrain = None
+  asset.data.root_link_pos_w[0, 0] = 100.0
+  result = terrain_edge_reached(env, threshold_fraction=0.95)
+  assert not result.any()
+
+
+@pytest.fixture
+def mock_grid_terrain_env():
+  device = get_test_device()
+  num_envs = 4
+
+  env = Mock()
+  env.num_envs = num_envs
+  env.device = device
+
+  # 10x10 grid of 8x8m sub-terrains → half_x = 40m, limit = 39.7m.
+  terrain = Mock()
+  terrain.cfg.terrain_type = "generator"
+  terrain.cfg.terrain_generator.size = (8.0, 8.0)
+  terrain.cfg.terrain_generator.border_width = 0.0
+  # Config num_rows/num_cols may differ from the effective grid (e.g. curriculum
+  # mode sets num_cols = len(sub_terrains) regardless of cfg.num_cols). The
+  # termination should read terrain_origins, not the config fields.
+  terrain.cfg.terrain_generator.num_rows = 999
+  terrain.cfg.terrain_generator.num_cols = 999
+  terrain.terrain_origins = torch.zeros(10, 10, 3, device=device)
+
+  env.scene.terrain = terrain
+
+  asset = Mock()
+  asset.data.root_link_pos_w = torch.zeros(num_envs, 3, device=device)
+  env.scene.__getitem__ = Mock(return_value=asset)
+
+  return env, asset
+
+
+def test_out_of_terrain_bounds_within(mock_grid_terrain_env):
+  env, asset = mock_grid_terrain_env
+  result = out_of_terrain_bounds(env)
+  assert not result.any()
+
+
+def test_out_of_terrain_bounds_outside(mock_grid_terrain_env):
+  env, asset = mock_grid_terrain_env
+  # Past the grid edge (limit_x = 40 - 0.3 = 39.7m).
+  asset.data.root_link_pos_w[2, 0] = 40.0
+  result = out_of_terrain_bounds(env)
+  assert result[2] and not result[0] and not result[1] and not result[3]
+
+
+def test_out_of_terrain_bounds_includes_border_width(mock_grid_terrain_env):
+  env, asset = mock_grid_terrain_env
+  # 2m flat border extends the footprint: half_x = 40 + 2 = 42m.
+  env.scene.terrain.cfg.terrain_generator.border_width = 2.0
+  asset.data.root_link_pos_w[0, 0] = 41.0  # Inside border, should not fire.
+  asset.data.root_link_pos_w[1, 0] = 42.0  # Past border edge (limit 41.7m).
+  result = out_of_terrain_bounds(env)
+  assert not result[0] and result[1]
diff --git a/tests/test_terrain_config.py b/tests/test_terrain_config.py
new file mode 100644
index 0000000..8b62942
--- /dev/null
+++ b/tests/test_terrain_config.py
@@ -0,0 +1,80 @@
+"""Tests for terrain configuration presets."""
+
+import mujoco
+import numpy as np
+import pytest
+
+import mjlab.terrains as terrain_gen
+from mjlab.terrains.config import (
+  ALL_TERRAIN_PRESETS,
+  ALL_TERRAINS_CFG,
+  ROUGH_TERRAINS_CFG,
+  STAIRS_TERRAINS_CFG,
+  pyramid_stairs,
+  terrain_preset,
+)
+from mjlab.terrains.terrain_generator import SubTerrainCfg
+
+
+def test_all_presets_return_sub_terrain_cfg():
+  for name, fn in ALL_TERRAIN_PRESETS.items():
+    cfg = fn(proportion=1.0)
+    assert isinstance(cfg, SubTerrainCfg), (
+      f"Preset {name!r} returned {type(cfg)}, expected SubTerrainCfg"
+    )
+
+
+def test_preset_overrides():
+  cfg = pyramid_stairs(proportion=0.5, step_width=0.5)
+  assert cfg.proportion == 0.5
+  assert cfg.step_width == 0.5
+  # Default should still apply for unoverridden fields.
+  assert cfg.platform_width == 3.0
+
+
+def test_rough_terrains_cfg_structure():
+  assert ROUGH_TERRAINS_CFG.size == (8.0, 8.0)
+  assert ROUGH_TERRAINS_CFG.num_rows == 10
+  assert ROUGH_TERRAINS_CFG.num_cols == 20
+  assert len(ROUGH_TERRAINS_CFG.sub_terrains) == 7
+  total = sum(c.proportion for c in ROUGH_TERRAINS_CFG.sub_terrains.values())
+  assert abs(total - 1.0) < 1e-6
+
+
+def test_stairs_terrains_cfg_structure():
+  assert STAIRS_TERRAINS_CFG.curriculum is True
+  assert len(STAIRS_TERRAINS_CFG.sub_terrains) == 4
+  assert "flat" in STAIRS_TERRAINS_CFG.sub_terrains
+  assert "easy_stairs" in STAIRS_TERRAINS_CFG.sub_terrains
+
+
+def test_all_terrains_cfg_matches_presets():
+  assert set(ALL_TERRAINS_CFG.sub_terrains.keys()) == set(ALL_TERRAIN_PRESETS.keys())
+  assert ALL_TERRAINS_CFG.num_cols == len(ALL_TERRAIN_PRESETS)
+
+
+def test_terrain_preset_decorator():
+  """Custom preset is registered in ALL_TERRAIN_PRESETS."""
+
+  @terrain_preset
+  def _test_custom(**overrides):
+    return terrain_gen.BoxFlatTerrainCfg(**overrides)
+
+  assert "_test_custom" in ALL_TERRAIN_PRESETS
+  cfg = ALL_TERRAIN_PRESETS["_test_custom"](proportion=0.5)
+  assert isinstance(cfg, SubTerrainCfg)
+  assert cfg.proportion == 0.5
+
+  # Clean up.
+  del ALL_TERRAIN_PRESETS["_test_custom"]
+
+
+@pytest.mark.slow
+def test_all_presets_generate_terrain():
+  """Each preset can generate terrain without error."""
+  for _name, fn in ALL_TERRAIN_PRESETS.items():
+    cfg = fn(proportion=1.0, size=(4.0, 4.0))
+    spec = mujoco.MjSpec()
+    spec.worldbody.add_body(name="terrain")
+    rng = np.random.default_rng(42)
+    cfg.function(difficulty=0.5, spec=spec, rng=rng)
diff --git a/tests/test_terrain_proportion_spawning.py b/tests/test_terrain_proportion_spawning.py
new file mode 100644
index 0000000..d1b1054
--- /dev/null
+++ b/tests/test_terrain_proportion_spawning.py
@@ -0,0 +1,201 @@
+"""Tests for proportion-based robot spawning on terrain columns."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+import torch
+
+from mjlab.terrains.primitive_terrains import BoxFlatTerrainCfg
+from mjlab.terrains.terrain_entity import TerrainEntity, TerrainEntityCfg
+from mjlab.terrains.terrain_generator import TerrainGenerator, TerrainGeneratorCfg
+
+
+@pytest.fixture(scope="module")
+def terrain_entity() -> TerrainEntity:
+  cfg = TerrainEntityCfg(terrain_type="plane", num_envs=1, env_spacing=2.0)
+  return TerrainEntity(cfg, device="cpu")
+
+
+def _make_origins(num_rows: int, num_cols: int) -> torch.Tensor:
+  origins = torch.zeros(num_rows, num_cols, 3)
+  for r in range(num_rows):
+    for c in range(num_cols):
+      origins[r, c, 0] = float(r)
+      origins[r, c, 1] = float(c)
+  return origins
+
+
+def _normalized(proportions: list[float]) -> np.ndarray:
+  p = np.array(proportions)
+  return p / p.sum()
+
+
+def _get_counts(entity: TerrainEntity, num_cols: int) -> list[int]:
+  return [int((entity.terrain_types == col).sum().item()) for col in range(num_cols)]
+
+
+# Fallback (no proportions).
+
+
+def test_even_distribution_without_proportions(terrain_entity: TerrainEntity) -> None:
+  num_envs = 30
+  num_cols = 3
+  origins = _make_origins(5, num_cols)
+
+  terrain_entity._compute_env_origins_curriculum(num_envs, origins, None)
+
+  assert _get_counts(terrain_entity, num_cols) == [10, 10, 10]
+
+
+# Proportional distribution.
+
+
+def test_basic_proportions(terrain_entity: TerrainEntity) -> None:
+  num_envs = 100
+  proportions = _normalized([0.5, 0.3, 0.2])
+  origins = _make_origins(5, len(proportions))
+
+  terrain_entity._compute_env_origins_curriculum(num_envs, origins, proportions)
+
+  assert _get_counts(terrain_entity, len(proportions)) == [50, 30, 20]
+
+
+@pytest.mark.parametrize("num_envs", [3, 7, 32, 64, 100, 512, 1024, 4096])
+def test_counts_sum_to_num_envs(terrain_entity: TerrainEntity, num_envs: int) -> None:
+  """Total terrain_types length must always equal num_envs."""
+  proportions = _normalized([0.6, 0.25, 0.1, 0.05])
+  origins = _make_origins(5, len(proportions))
+
+  terrain_entity._compute_env_origins_curriculum(num_envs, origins, proportions)
+
+  assert len(terrain_entity.terrain_types) == num_envs
+
+
+@pytest.mark.parametrize(
+  "num_envs, proportions",
+  [
+    (3, [0.98, 0.01, 0.01]),
+    (5, [0.9, 0.05, 0.03, 0.01, 0.01]),
+    (100, [0.9, 0.05, 0.05]),
+    (10, [0.97, 0.01, 0.01, 0.01]),
+  ],
+)
+def test_every_column_gets_at_least_one(
+  terrain_entity: TerrainEntity, num_envs: int, proportions: list[float]
+) -> None:
+  """When num_envs >= num_cols, every column gets at least 1 robot."""
+  p = _normalized(proportions)
+  origins = _make_origins(5, len(p))
+
+  terrain_entity._compute_env_origins_curriculum(num_envs, origins, p)
+
+  counts = _get_counts(terrain_entity, len(p))
+  for col, count in enumerate(counts):
+    assert count >= 1, f"Column {col} got 0 envs (counts={counts})"
+
+
+def test_fewer_envs_than_cols(terrain_entity: TerrainEntity) -> None:
+  """When num_envs < num_cols, should still work without errors."""
+  num_envs = 2
+  proportions = _normalized([0.5, 0.3, 0.1, 0.1])
+  origins = _make_origins(5, len(proportions))
+
+  result = terrain_entity._compute_env_origins_curriculum(
+    num_envs, origins, proportions
+  )
+
+  assert len(terrain_entity.terrain_types) == num_envs
+  assert result.shape == (num_envs, 3)
+
+
+def test_equal_proportions_gives_equal_counts(terrain_entity: TerrainEntity) -> None:
+  num_envs = 30
+  proportions = _normalized([1.0, 1.0, 1.0, 1.0])
+  origins = _make_origins(5, len(proportions))
+
+  terrain_entity._compute_env_origins_curriculum(num_envs, origins, proportions)
+
+  counts = _get_counts(terrain_entity, len(proportions))
+  for c in counts:
+    assert 7 <= c <= 8, f"Expected 7 or 8 envs per column, got {c}"
+
+
+def test_env_origins_shape(terrain_entity: TerrainEntity) -> None:
+  num_envs = 20
+  proportions = _normalized([0.5, 0.3, 0.2])
+  origins = _make_origins(5, len(proportions))
+
+  result = terrain_entity._compute_env_origins_curriculum(
+    num_envs, origins, proportions
+  )
+
+  assert result.shape == (num_envs, 3)
+
+
+def test_env_origins_match_terrain_origins(terrain_entity: TerrainEntity) -> None:
+  """Each env_origin must correspond to a valid (level, type) in origins."""
+  num_envs = 50
+  proportions = _normalized([0.6, 0.3, 0.1])
+  origins = _make_origins(5, len(proportions))
+
+  result = terrain_entity._compute_env_origins_curriculum(
+    num_envs, origins, proportions
+  )
+
+  for i in range(num_envs):
+    level = int(terrain_entity.terrain_levels[i].item())
+    ttype = int(terrain_entity.terrain_types[i].item())
+    expected = origins[level, ttype]
+    assert torch.allclose(result[i], expected), (
+      f"env {i}: origin {result[i].tolist()} != "
+      f"origins[{level},{ttype}]={expected.tolist()}"
+    )
+
+
+def test_mismatched_cols_falls_back_to_even(terrain_entity: TerrainEntity) -> None:
+  """When proportions length != num_cols, should fall back to even."""
+  num_envs = 30
+  num_cols = 3
+  # 4 proportions but only 3 columns in origins.
+  proportions = _normalized([0.4, 0.3, 0.2, 0.1])
+  origins = _make_origins(5, num_cols)
+
+  terrain_entity._compute_env_origins_curriculum(num_envs, origins, proportions)
+
+  assert _get_counts(terrain_entity, num_cols) == [10, 10, 10]
+
+
+def test_proportions_are_respected_approximately(
+  terrain_entity: TerrainEntity,
+) -> None:
+  """With large num_envs, actual distribution should track proportions."""
+  num_envs = 10000
+  raw = [0.5, 0.3, 0.15, 0.05]
+  proportions = _normalized(raw)
+  origins = _make_origins(5, len(proportions))
+
+  terrain_entity._compute_env_origins_curriculum(num_envs, origins, proportions)
+
+  counts = _get_counts(terrain_entity, len(proportions))
+  for col, (count, prop) in enumerate(zip(counts, proportions, strict=True)):
+    expected = prop * num_envs
+    assert abs(count - expected) < 10, (
+      f"Column {col}: got {count}, expected ~{expected:.0f}"
+    )
+
+
+def test_generator_does_not_mutate_cfg_num_cols() -> None:
+  """TerrainGenerator must not mutate the caller's cfg.num_cols."""
+  cfg = TerrainGeneratorCfg(
+    size=(4.0, 4.0),
+    curriculum=True,
+    num_cols=1,
+    sub_terrains={
+      "a": BoxFlatTerrainCfg(proportion=0.5, size=(4.0, 4.0)),
+      "b": BoxFlatTerrainCfg(proportion=0.3, size=(4.0, 4.0)),
+      "c": BoxFlatTerrainCfg(proportion=0.2, size=(4.0, 4.0)),
+    },
+  )
+  TerrainGenerator(cfg)
+  assert cfg.num_cols == 1, f"cfg.num_cols was mutated to {cfg.num_cols}"
diff --git a/tests/test_terrain_utils.py b/tests/test_terrain_utils.py
new file mode 100644
index 0000000..a4c22d7
--- /dev/null
+++ b/tests/test_terrain_utils.py
@@ -0,0 +1,188 @@
+"""Tests for terrain normal fitting from sensor hit points."""
+
+from unittest.mock import MagicMock, PropertyMock
+
+import torch
+
+from mjlab.sensor import RayCastData, RayCastSensor
+from mjlab.tasks.velocity.mdp.terrain_utils import (
+  fit_terrain_normal,
+  terrain_normal_from_sensors,
+)
+
+
+def test_flat_ground():
+  """Points on z=0 plane → normal = [0, 0, 1]."""
+  B, N = 4, 10
+  points = torch.zeros(B, N, 3)
+  torch.manual_seed(0)
+  points[:, :, 0] = torch.randn(B, N)
+  points[:, :, 1] = torch.randn(B, N)
+  valid_mask = torch.ones(B, N, dtype=torch.bool)
+
+  normal = fit_terrain_normal(points, valid_mask)
+
+  assert normal.shape == (B, 3)
+  expected = torch.tensor([0.0, 0.0, 1.0])
+  for b in range(B):
+    torch.testing.assert_close(normal[b], expected, atol=1e-5, rtol=1e-5)
+
+
+def test_tilted_plane():
+  """Points on z = 0.5*x plane → normal perpendicular to that."""
+  B, N = 2, 20
+  torch.manual_seed(42)
+  points = torch.zeros(B, N, 3)
+  x = torch.randn(B, N)
+  y = torch.randn(B, N)
+  points[:, :, 0] = x
+  points[:, :, 1] = y
+  points[:, :, 2] = 0.5 * x
+  valid_mask = torch.ones(B, N, dtype=torch.bool)
+
+  normal = fit_terrain_normal(points, valid_mask)
+
+  # Normal to plane z = 0.5*x is (-0.5, 0, 1) normalized.
+  expected_raw = torch.tensor([-0.5, 0.0, 1.0])
+  expected = expected_raw / expected_raw.norm()
+  assert normal.shape == (B, 3)
+  for b in range(B):
+    torch.testing.assert_close(normal[b], expected, atol=1e-4, rtol=1e-4)
+
+
+def test_partial_misses():
+  """Half invalid points with junk z values → still correct normal."""
+  B, N = 2, 20
+  torch.manual_seed(42)
+  points = torch.zeros(B, N, 3)
+  points[:, :, 0] = torch.randn(B, N)
+  points[:, :, 1] = torch.randn(B, N)
+  valid_mask = torch.ones(B, N, dtype=torch.bool)
+  # Invalidate even-indexed points and put junk in them.
+  valid_mask[:, ::2] = False
+  points[:, ::2, 2] = 999.0
+
+  normal = fit_terrain_normal(points, valid_mask)
+
+  expected = torch.tensor([0.0, 0.0, 1.0])
+  assert normal.shape == (B, 3)
+  for b in range(B):
+    torch.testing.assert_close(normal[b], expected, atol=1e-4, rtol=1e-4)
+
+
+def test_fewer_than_3_valid_fallback():
+  """Fewer than 3 valid points (including zero) falls back to [0, 0, 1]."""
+  B, N = 3, 10
+  points = torch.randn(B, N, 3)
+  valid_mask = torch.zeros(B, N, dtype=torch.bool)
+  # Batch 0: 0 valid, batch 1: 1 valid, batch 2: 2 valid.
+  valid_mask[1, 0] = True
+  valid_mask[2, :2] = True
+
+  normal = fit_terrain_normal(points, valid_mask)
+
+  expected = torch.tensor([0.0, 0.0, 1.0])
+  for b in range(B):
+    torch.testing.assert_close(normal[b], expected, atol=1e-6, rtol=1e-6)
+
+
+def test_collinear_points_fallback():
+  """Collinear points don't define a plane, should fall back to [0, 0, 1]."""
+  B, N = 2, 10
+  points = torch.zeros(B, N, 3)
+  # All points along the X axis.
+  points[:, :, 0] = torch.linspace(0, 1, N)
+  valid_mask = torch.ones(B, N, dtype=torch.bool)
+
+  normal = fit_terrain_normal(points, valid_mask)
+
+  expected = torch.tensor([0.0, 0.0, 1.0])
+  for b in range(B):
+    torch.testing.assert_close(normal[b], expected, atol=1e-6, rtol=1e-6)
+
+
+def test_non_finite_points_fallback():
+  """Non-finite hits (from a diverged env) must not crash eigh; fall back to up."""
+  B, N = 3, 10
+  points = torch.zeros(B, N, 3)
+  # Batch 0: a valid tilted plane.
+  points[0, :, 0] = torch.linspace(0, 1, N)
+  points[0, :, 1] = torch.linspace(0, 1, N)
+  points[0, :, 2] = 0.2 * points[0, :, 0]
+  # Batch 1: all NaN. Batch 2: all Inf.
+  points[1] = float("nan")
+  points[2] = float("inf")
+  valid_mask = torch.ones(B, N, dtype=torch.bool)
+
+  normal = fit_terrain_normal(points, valid_mask)
+
+  assert torch.isfinite(normal).all()
+  expected_up = torch.tensor([0.0, 0.0, 1.0])
+  torch.testing.assert_close(normal[1], expected_up, atol=1e-6, rtol=1e-6)
+  torch.testing.assert_close(normal[2], expected_up, atol=1e-6, rtol=1e-6)
+  # The valid plane is still fit and points upward.
+  assert normal[0, 2] > 0
+  torch.testing.assert_close(normal[0].norm(), torch.tensor(1.0), atol=1e-4, rtol=0)
+
+
+def test_small_valid_plane_still_fits():
+  """A tiny but planar patch should not be rejected as degenerate."""
+  x_vals = torch.linspace(0.0, 1e-4, 4)
+  y_vals = torch.linspace(0.0, 8e-5, 3)
+  xx, yy = torch.meshgrid(x_vals, y_vals, indexing="ij")
+  patch = torch.stack((xx.reshape(-1), yy.reshape(-1)), dim=-1)
+  N = patch.shape[0]
+  B = 2
+  points = torch.zeros(B, N, 3)
+  points[:, :, 0] = patch[:, 0]
+  points[:, :, 1] = patch[:, 1]
+  points[:, :, 2] = 0.5 * patch[:, 0]
+  valid_mask = torch.ones(B, N, dtype=torch.bool)
+
+  normal = fit_terrain_normal(points, valid_mask)
+
+  expected_raw = torch.tensor([-0.5, 0.0, 1.0])
+  expected = expected_raw / expected_raw.norm()
+  for b in range(B):
+    torch.testing.assert_close(normal[b], expected, atol=1e-4, rtol=1e-4)
+
+
+def test_terrain_normal_from_sensors():
+  """Mock env/sensors, verify subsampling + concatenation."""
+  B = 4
+  torch.manual_seed(7)
+
+  # RayCastSensor mock: 100 rays, all hits on z=0.
+  raycast_hit_pos = torch.zeros(B, 100, 3)
+  raycast_hit_pos[:, :, 0] = torch.randn(B, 100)
+  raycast_hit_pos[:, :, 1] = torch.randn(B, 100)
+  raycast_distances = torch.ones(B, 100)  # all valid
+
+  raycast_sensor = MagicMock(spec=RayCastSensor)
+  raycast_data = RayCastData(
+    distances=raycast_distances,
+    normals_w=torch.zeros(B, 100, 3),
+    hit_pos_w=raycast_hit_pos,
+    pos_w=torch.zeros(B, 3),
+    quat_w=torch.zeros(B, 4),
+    frame_pos_w=torch.zeros(B, 1, 3),
+    frame_quat_w=torch.zeros(B, 1, 4),
+  )
+  type(raycast_sensor).data = PropertyMock(return_value=raycast_data)
+
+  # Mock env.
+  sensors = {"raycast": raycast_sensor}
+  env = MagicMock()
+  env.scene.__getitem__ = MagicMock(side_effect=lambda name: sensors[name])
+
+  normal = terrain_normal_from_sensors(
+    env,
+    sensor_names=("raycast",),
+    max_points=16,
+  )
+
+  # 16 subsampled raycast points on z=0.
+  assert normal.shape == (B, 3)
+  expected = torch.tensor([0.0, 0.0, 1.0])
+  for b in range(B):
+    torch.testing.assert_close(normal[b], expected, atol=1e-4, rtol=1e-4)
diff --git a/tests/test_terrains.py b/tests/test_terrains.py
new file mode 100644
index 0000000..e5a90b3
--- /dev/null
+++ b/tests/test_terrains.py
@@ -0,0 +1,180 @@
+"""Tests for terrain generation."""
+
+from dataclasses import dataclass
+
+import mujoco
+import numpy as np
+import pytest
+
+from mjlab.terrains.config import ALL_TERRAIN_PRESETS
+from mjlab.terrains.primitive_terrains import (
+  _MIN_BORDER_HEIGHT,
+  BoxInvertedPyramidStairsTerrainCfg,
+  BoxPyramidStairsTerrainCfg,
+  BoxSteppingStonesTerrainCfg,
+)
+from mjlab.terrains.terrain_generator import (
+  SubTerrainCfg,
+  TerrainGenerator,
+  TerrainGeneratorCfg,
+  TerrainGeometry,
+  TerrainOutput,
+)
+
+_CFG = BoxSteppingStonesTerrainCfg(
+  proportion=1.0,
+  size=(8.0, 8.0),
+  stone_size_range=(0.2, 0.6),
+  stone_distance_range=(0.05, 0.25),
+  stone_height=0.2,
+  stone_height_variation=0.05,
+  stone_size_variation=0.05,
+  displacement_range=0.1,
+  floor_depth=2.0,
+  platform_width=1.5,
+  border_width=0.25,
+)
+
+
+def _generate_stones(
+  cfg: BoxSteppingStonesTerrainCfg,
+  difficulty: float,
+  rng: np.random.Generator,
+) -> list[tuple[float, float, float, float]]:
+  """Generate terrain and return stone (cx, cy, half_x, half_y) tuples."""
+  spec = mujoco.MjSpec()
+  spec.worldbody.add_body(name="terrain")
+  output = cfg.function(difficulty=difficulty, spec=spec, rng=rng)
+
+  center = cfg.size[0] / 2
+  stones = []
+  for geom_info in output.geometries:
+    geom = geom_info.geom
+    if geom is None:
+      continue
+    pos, size = geom.pos, geom.size
+    # Skip platform, floor, and border geoms. The platform is the geom centered
+    # exactly at the patch center (its size is grid-snapped, not the configured
+    # width, so it is identified by position alone).
+    is_platform = np.isclose(pos[0], center) and np.isclose(pos[1], center)
+    is_full_span = np.isclose(size[0], cfg.size[0] / 2) or np.isclose(
+      size[1], cfg.size[1] / 2
+    )
+    if is_platform or is_full_span:
+      continue
+    stones.append((pos[0], pos[1], size[0], size[1]))
+  return stones
+
+
+def test_no_stone_centers_inside_platform():
+  """No stone center should fall inside the platform."""
+  center = _CFG.size[0] / 2
+  p_half = _CFG.platform_width / 2
+  p_min, p_max = center - p_half, center + p_half
+
+  for difficulty in [0.0, 0.5, 1.0]:
+    stones = _generate_stones(_CFG, difficulty, np.random.default_rng(42))
+    for cx, cy, _, _ in stones:
+      assert not (p_min <= cx <= p_max and p_min <= cy <= p_max), (
+        f"Stone at ({cx:.3f}, {cy:.3f}) inside platform at difficulty={difficulty}"
+      )
+
+
+def test_stone_size_decreases_with_difficulty():
+  """Average stone size should be smaller at higher difficulty."""
+  sizes = {}
+  for difficulty in [0.0, 1.0]:
+    stones = _generate_stones(_CFG, difficulty, np.random.default_rng(42))
+    sizes[difficulty] = np.mean([hx + hy for _, _, hx, hy in stones])
+
+  assert sizes[0.0] > sizes[1.0]
+
+
+@pytest.mark.parametrize(
+  "cfg_cls", [BoxPyramidStairsTerrainCfg, BoxInvertedPyramidStairsTerrainCfg]
+)
+def test_pyramid_stairs_border_present_at_zero_difficulty(cfg_cls):
+  """At difficulty 0 the step height collapses to 0, but the flat border frame
+  must still be generated as solid, non-degenerate geometry (regression for the
+  empty-boundary bug, issue #1033)."""
+  cfg = cfg_cls(
+    size=(8.0, 8.0),
+    step_height_range=(0.0, 0.2),
+    step_width=0.3,
+    platform_width=3.0,
+    border_width=1.0,
+  )
+  spec = mujoco.MjSpec()
+  spec.worldbody.add_body(name="terrain")
+  output = cfg.function(difficulty=0.0, spec=spec, rng=np.random.default_rng(0))
+
+  # The border frame sits below z=0 (top flush at ground level); inner step
+  # boxes are centered at z=0. Identify the frame by its downward offset.
+  border_geoms = [
+    g.geom for g in output.geometries if g.geom is not None and g.geom.pos[2] < -1e-4
+  ]
+  assert len(border_geoms) == 4, "Expected four border frame boxes."
+  for geom in border_geoms:
+    # Each frame box must be solid, not a degenerate zero-height geom, and its
+    # top must be flush with the ground plane at z=0.
+    assert geom.size[2] >= _MIN_BORDER_HEIGHT / 2 - 1e-9
+    assert np.isclose(geom.pos[2] + geom.size[2], 0.0, atol=1e-6)
+
+
+@pytest.mark.parametrize("preset_name", sorted(ALL_TERRAIN_PRESETS))
+@pytest.mark.parametrize("difficulty", [0.0, 1.0])
+def test_preset_compiles_across_difficulty(preset_name, difficulty):
+  """Every terrain preset must generate compilable MuJoCo geometry across the
+  full difficulty range. Difficulty 0 is exercised explicitly because curriculum
+  row 0 lands there deterministically, which previously produced degenerate
+  geometry (zero-height hfields, NaN colors, missing borders)."""
+  cfg = ALL_TERRAIN_PRESETS[preset_name](size=(8.0, 8.0))
+  spec = mujoco.MjSpec()
+  spec.worldbody.add_body(name="terrain")
+  cfg.function(difficulty=difficulty, spec=spec, rng=np.random.default_rng(0))
+  # Compiling validates geom/hfield sizes and rgba values (catches NaNs and
+  # non-positive sizes that MuJoCo rejects).
+  spec.compile()
+
+
+@dataclass(kw_only=True)
+class _BoxesTerrainCfg(SubTerrainCfg):
+  """Test terrain that emits two boxes, named per `names` (None leaves unnamed)."""
+
+  names: tuple[str | None, str | None] = (None, None)
+
+  def function(
+    self, difficulty: float, spec: mujoco.MjSpec, rng: np.random.Generator
+  ) -> TerrainOutput:
+    del difficulty, rng
+    body = spec.body("terrain")
+    geometries = []
+    for i in range(2):
+      geom = body.add_geom(
+        type=mujoco.mjtGeom.mjGEOM_BOX,
+        size=(0.5, 0.5, 0.5),
+        pos=(i, 0, 0),
+        name=self.names[i],
+      )
+      geometries.append(TerrainGeometry(geom=geom))
+    return TerrainOutput(origin=np.zeros(3), geometries=geometries)
+
+
+def test_compile_preserves_custom_names_and_defaults_unnamed_geoms():
+  """Geoms with a custom name from a sub-terrain must be preserved, while
+  unnamed geoms must fall back to the generator's default "terrain_{i}" name."""
+  cfg = TerrainGeneratorCfg(
+    size=(4.0, 4.0),
+    curriculum=True,
+    sub_terrains={
+      "named": _BoxesTerrainCfg(size=(4.0, 4.0), names=("foo_0", "foo_1")),
+      "unnamed": _BoxesTerrainCfg(size=(4.0, 4.0)),
+    },
+  )
+  generator = TerrainGenerator(cfg)
+  spec = mujoco.MjSpec()
+  generator.compile(spec)
+  model = spec.compile()
+
+  names = [model.geom(i).name for i in range(model.ngeom)]
+  assert names == ["foo_0", "foo_1", "terrain_2", "terrain_3"]
diff --git a/tests/test_tracking_metrics.py b/tests/test_tracking_metrics.py
new file mode 100644
index 0000000..388f264
--- /dev/null
+++ b/tests/test_tracking_metrics.py
@@ -0,0 +1,179 @@
+"""Tests for motion tracking evaluation metrics."""
+
+import math
+from unittest.mock import Mock
+
+import pytest
+import torch
+
+from mjlab.tasks.tracking.mdp.metrics import (
+  compute_ee_orientation_error,
+  compute_ee_position_error,
+  compute_joint_velocity_error,
+  compute_mpkpe,
+  compute_root_relative_mpkpe,
+)
+
+
+@pytest.fixture
+def mock_command():
+  """Create a mock MotionCommand for testing."""
+  command = Mock()
+  command.num_envs = 4
+  command.device = "cpu"
+  command.cfg = Mock()
+  command.cfg.body_names = (
+    "pelvis",
+    "left_knee",
+    "right_knee",
+    "left_ankle",
+    "right_ankle",
+    "left_wrist",
+    "right_wrist",
+  )
+  return command
+
+
+def test_mpkpe_zero_when_positions_match(mock_command):
+  """Test MPKPE is zero when global positions are identical."""
+  num_bodies = len(mock_command.cfg.body_names)
+  positions = torch.rand(mock_command.num_envs, num_bodies, 3)
+
+  mock_command.body_pos_w = positions.clone()
+  mock_command.robot_body_pos_w = positions.clone()
+
+  mpkpe = compute_mpkpe(mock_command)
+
+  assert mpkpe.shape == (mock_command.num_envs,)
+  assert torch.allclose(mpkpe, torch.zeros(mock_command.num_envs), atol=1e-6)
+
+
+def test_mpkpe_correct_error(mock_command):
+  """Test MPKPE computes the correct mean global error."""
+  num_bodies = len(mock_command.cfg.body_names)
+
+  mock_command.body_pos_w = torch.zeros(mock_command.num_envs, num_bodies, 3)
+  mock_command.robot_body_pos_w = torch.zeros(mock_command.num_envs, num_bodies, 3)
+  mock_command.robot_body_pos_w[:, :, 0] = 1.0  # 1 unit offset in x
+
+  mpkpe = compute_mpkpe(mock_command)
+
+  assert torch.allclose(mpkpe, torch.ones(mock_command.num_envs), atol=1e-6)
+
+
+def test_mpkpe_uses_global_reference(mock_command):
+  """MPKPE must read the global reference, not the drift-cancelled one.
+
+  Pins issue #1006: setting body_pos_relative_w to match the robot exactly
+  would yield zero error if it were (incorrectly) used; the metric must
+  instead follow body_pos_w.
+  """
+  num_bodies = len(mock_command.cfg.body_names)
+  robot_pos = torch.rand(mock_command.num_envs, num_bodies, 3)
+  mock_command.robot_body_pos_w = robot_pos.clone()
+  mock_command.body_pos_relative_w = robot_pos.clone()  # zero error if misused
+  mock_command.body_pos_w = robot_pos.clone()
+  mock_command.body_pos_w[:, :, 0] += 1.0  # 1 unit of global drift
+
+  mpkpe = compute_mpkpe(mock_command)
+
+  assert torch.allclose(mpkpe, torch.ones(mock_command.num_envs), atol=1e-6)
+
+
+def test_r_mpkpe_zero_when_relative_positions_match(mock_command):
+  """R-MPKPE is zero when re-anchored positions are identical."""
+  num_bodies = len(mock_command.cfg.body_names)
+  positions = torch.rand(mock_command.num_envs, num_bodies, 3)
+
+  mock_command.body_pos_relative_w = positions.clone()
+  mock_command.robot_body_pos_w = positions.clone()
+
+  r_mpkpe = compute_root_relative_mpkpe(mock_command)
+
+  assert r_mpkpe.shape == (mock_command.num_envs,)
+  assert torch.allclose(r_mpkpe, torch.zeros(mock_command.num_envs), atol=1e-6)
+
+
+def test_r_mpkpe_uses_relative_reference(mock_command):
+  """R-MPKPE reads the re-anchored reference, not the global one.
+
+  Setting body_pos_w to match the robot exactly would yield zero error if
+  it were (incorrectly) used; the metric must instead follow
+  body_pos_relative_w.
+  """
+  num_bodies = len(mock_command.cfg.body_names)
+  robot_pos = torch.rand(mock_command.num_envs, num_bodies, 3)
+  mock_command.robot_body_pos_w = robot_pos.clone()
+  mock_command.body_pos_w = robot_pos.clone()  # zero error if misused
+  mock_command.body_pos_relative_w = robot_pos.clone()
+  mock_command.body_pos_relative_w[:, :, 0] += 1.0  # 1 unit of local pose error
+
+  r_mpkpe = compute_root_relative_mpkpe(mock_command)
+
+  assert torch.allclose(r_mpkpe, torch.ones(mock_command.num_envs), atol=1e-6)
+
+
+def test_joint_velocity_error_rms(mock_command):
+  """Joint velocity error is the per-joint RMS of the velocity error."""
+  num_joints = 3
+
+  mock_command.joint_vel = torch.zeros(mock_command.num_envs, num_joints)
+  mock_command.robot_joint_vel = torch.zeros(mock_command.num_envs, num_joints)
+  mock_command.robot_joint_vel[:, 0] = 3.0
+  mock_command.robot_joint_vel[:, 1] = 4.0  # Error [3, 4, 0]
+
+  error = compute_joint_velocity_error(mock_command)
+
+  expected = math.sqrt((3.0**2 + 4.0**2 + 0.0**2) / num_joints)
+  assert torch.allclose(error, torch.ones(mock_command.num_envs) * expected, atol=1e-6)
+
+
+def test_ee_position_error_only_uses_specified_bodies(mock_command):
+  """Test EE position error only uses specified bodies."""
+  num_bodies = len(mock_command.cfg.body_names)
+
+  mock_command.body_pos_relative_w = torch.zeros(mock_command.num_envs, num_bodies, 3)
+  mock_command.robot_body_pos_w = torch.zeros(mock_command.num_envs, num_bodies, 3)
+
+  # Large error for pelvis (not an EE).
+  mock_command.robot_body_pos_w[:, 0, :] = 100.0
+  # Small error for ankles.
+  mock_command.robot_body_pos_w[:, 3, 0] = 1.0  # left_ankle
+  mock_command.robot_body_pos_w[:, 4, 0] = 1.0  # right_ankle
+
+  error = compute_ee_position_error(mock_command, ("left_ankle", "right_ankle"))
+
+  # Should only reflect ankle error, not pelvis.
+  assert torch.allclose(error, torch.ones(mock_command.num_envs), atol=1e-6)
+
+
+def test_ee_orientation_error_detects_rotation(mock_command):
+  """Test EE orientation error detects rotations."""
+  num_bodies = len(mock_command.cfg.body_names)
+
+  identity_quat = torch.tensor([1.0, 0.0, 0.0, 0.0])
+  mock_command.body_quat_relative_w = (
+    identity_quat.view(1, 1, 4).expand(mock_command.num_envs, num_bodies, 4).clone()
+  )
+
+  # 90 degree rotation around z-axis.
+  rotated_quat = torch.tensor([0.7071, 0.0, 0.0, 0.7071])
+  mock_command.robot_body_quat_w = (
+    rotated_quat.view(1, 1, 4).expand(mock_command.num_envs, num_bodies, 4).clone()
+  )
+
+  error = compute_ee_orientation_error(mock_command, ("left_wrist",))
+
+  # Error should be approximately pi/2 radians.
+  expected = torch.ones(mock_command.num_envs) * (3.14159 / 2)
+  assert torch.allclose(error, expected, atol=0.01)
+
+
+def test_ee_metrics_raise_on_unknown_body(mock_command):
+  """Unknown end-effector names raise instead of silently scoring zero."""
+  num_bodies = len(mock_command.cfg.body_names)
+  mock_command.body_pos_relative_w = torch.zeros(mock_command.num_envs, num_bodies, 3)
+  mock_command.robot_body_pos_w = torch.zeros(mock_command.num_envs, num_bodies, 3)
+
+  with pytest.raises(ValueError, match="not tracked"):
+    compute_ee_position_error(mock_command, ("nonexistent_body",))
diff --git a/tests/test_tracking_task.py b/tests/test_tracking_task.py
new file mode 100644
index 0000000..ef09668
--- /dev/null
+++ b/tests/test_tracking_task.py
@@ -0,0 +1,134 @@
+"""Tests specific to motion tracking tasks."""
+
+import pytest
+
+from mjlab.asset_zoo.robots import G1_ACTION_SCALE
+from mjlab.envs.mdp.actions import JointPositionActionCfg
+from mjlab.tasks.registry import list_tasks, load_env_cfg
+from mjlab.tasks.tracking.mdp import MotionCommandCfg
+
+
+@pytest.fixture(scope="module")
+def tracking_task_ids() -> list[str]:
+  """Get all tracking task IDs."""
+  return [t for t in list_tasks() if "Tracking" in t]
+
+
+@pytest.fixture(scope="module")
+def g1_tracking_task_ids(tracking_task_ids: list[str]) -> list[str]:
+  """Get all G1 tracking task IDs."""
+  return [t for t in tracking_task_ids if "G1" in t]
+
+
+def test_tracking_tasks_have_motion_command(tracking_task_ids: list[str]) -> None:
+  """All tracking tasks should have a 'motion' command of type MotionCommandCfg."""
+  for task_id in tracking_task_ids:
+    cfg = load_env_cfg(task_id)
+
+    assert "motion" in cfg.commands, f"Task {task_id} missing 'motion' command"
+
+    motion_cmd = cfg.commands["motion"]
+    assert isinstance(motion_cmd, MotionCommandCfg), (
+      f"Task {task_id} motion command is not MotionCommandCfg"
+    )
+
+
+def test_tracking_tasks_have_self_collision_sensor(
+  tracking_task_ids: list[str],
+) -> None:
+  """All tracking tasks should have a self_collision sensor."""
+  for task_id in tracking_task_ids:
+    cfg = load_env_cfg(task_id)
+
+    assert cfg.scene.sensors is not None, f"Task {task_id} has no sensors"
+
+    sensor_names = {s.name for s in cfg.scene.sensors}
+    assert "self_collision" in sensor_names, (
+      f"Task {task_id} missing self_collision sensor"
+    )
+
+
+def test_tracking_no_state_estimation_observations() -> None:
+  """No-state-estimation tasks remove observations that depend on state estimation."""
+  task_id = "Mjlab-Tracking-Flat-Unitree-G1-No-State-Estimation"
+
+  # Test both training and play modes
+  for play_mode in [False, True]:
+    cfg = load_env_cfg(task_id, play=play_mode)
+    mode_str = "play mode" if play_mode else "training mode"
+
+    assert "actor" in cfg.observations, (
+      f"Task {task_id} ({mode_str}) missing policy observations"
+    )
+    actor_terms = cfg.observations["actor"].terms
+
+    assert "motion_anchor_pos_b" not in actor_terms, (
+      f"Task {task_id} ({mode_str}) has motion_anchor_pos_b in policy, "
+      "expected it to be removed for no-state-estimation variant"
+    )
+    assert "base_lin_vel" not in actor_terms, (
+      f"Task {task_id} ({mode_str}) has base_lin_vel in policy, "
+      "expected it to be removed for no-state-estimation variant"
+    )
+
+
+def test_tracking_play_disables_rsi_randomization() -> None:
+  """Tracking play tasks should disable RSI randomization."""
+  tracking_tasks = [
+    "Mjlab-Tracking-Flat-Unitree-G1",
+    "Mjlab-Tracking-Flat-Unitree-G1-No-State-Estimation",
+  ]
+
+  for task_id in tracking_tasks:
+    cfg = load_env_cfg(task_id, play=True)
+
+    motion_cmd = cfg.commands["motion"]
+    assert isinstance(motion_cmd, MotionCommandCfg), (
+      f"Task {task_id} (play mode) motion command is not MotionCommandCfg"
+    )
+
+    assert motion_cmd.pose_range == {}, (
+      f"Task {task_id} (play mode) has non-empty pose_range={motion_cmd.pose_range}, "
+      "expected empty dict for disabled RSI"
+    )
+    assert motion_cmd.velocity_range == {}, (
+      f"Task {task_id} (play mode) has non-empty velocity_range={motion_cmd.velocity_range}, "
+      "expected empty dict for disabled RSI"
+    )
+
+
+def test_tracking_play_uses_start_sampling_mode() -> None:
+  """Tracking play tasks should use sampling_mode='start'."""
+  tracking_tasks = [
+    "Mjlab-Tracking-Flat-Unitree-G1",
+    "Mjlab-Tracking-Flat-Unitree-G1-No-State-Estimation",
+  ]
+
+  for task_id in tracking_tasks:
+    cfg = load_env_cfg(task_id, play=True)
+
+    motion_cmd = cfg.commands["motion"]
+    assert isinstance(motion_cmd, MotionCommandCfg), (
+      f"Task {task_id} (play mode) motion command is not MotionCommandCfg"
+    )
+
+    assert motion_cmd.sampling_mode == "start", (
+      f"Task {task_id} (play mode) sampling_mode={motion_cmd.sampling_mode}, expected 'start'"
+    )
+
+
+def test_g1_tracking_has_correct_action_scale(g1_tracking_task_ids: list[str]) -> None:
+  """G1 tracking tasks should use G1_ACTION_SCALE."""
+  for task_id in g1_tracking_task_ids:
+    cfg = load_env_cfg(task_id)
+
+    assert "joint_pos" in cfg.actions, f"Task {task_id} missing 'joint_pos' action"
+
+    joint_pos_action = cfg.actions["joint_pos"]
+    assert isinstance(joint_pos_action, JointPositionActionCfg), (
+      f"Task {task_id} joint_pos action is not JointPositionActionCfg"
+    )
+
+    assert joint_pos_action.scale == G1_ACTION_SCALE, (
+      f"Task {task_id} action scale mismatch, expected G1_ACTION_SCALE"
+    )
diff --git a/tests/test_tyro_defaults.py b/tests/test_tyro_defaults.py
new file mode 100644
index 0000000..03285ca
--- /dev/null
+++ b/tests/test_tyro_defaults.py
@@ -0,0 +1,30 @@
+import tyro
+
+from mjlab.envs import ManagerBasedRlEnvCfg
+from mjlab.rl import RslRlOnPolicyRunnerCfg
+from mjlab.scene import SceneCfg
+from mjlab.scripts.train import TrainConfig
+from mjlab.terrains import TerrainEntityCfg
+
+
+def test_tyro_defaults():
+  """Regression test for #677 due to incompatibilities between declared types and
+  default values of the env configs.
+  """
+  tyro.cli(
+    TrainConfig,
+    default=TrainConfig(
+      env=ManagerBasedRlEnvCfg(
+        decimation=5,
+        scene=SceneCfg(
+          terrain=TerrainEntityCfg(),
+        ),
+      ),
+      agent=RslRlOnPolicyRunnerCfg(),
+    ),
+    config=(
+      tyro.conf.AvoidSubcommands,
+      tyro.conf.FlagConversionOff,
+    ),
+    args=[],
+  )
diff --git a/tests/test_tyro_flags.py b/tests/test_tyro_flags.py
new file mode 100644
index 0000000..fd31053
--- /dev/null
+++ b/tests/test_tyro_flags.py
@@ -0,0 +1,76 @@
+"""Test that all tyro.cli() calls include mjlab.TYRO_FLAGS."""
+
+import ast
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).parent.parent
+SEARCH_DIRS = [ROOT / "src", ROOT / "scripts"]
+
+
+def find_tyro_cli_calls() -> list[tuple[Path, int, bool]]:
+  """Find all tyro.cli() calls and check if they have TYRO_FLAGS.
+
+  Returns a list of (filepath, line_number, has_tyro_flags) tuples.
+  """
+  results = []
+
+  for search_dir in SEARCH_DIRS:
+    if not search_dir.exists():
+      continue
+    for filepath in search_dir.rglob("*.py"):
+      try:
+        source = filepath.read_text()
+        tree = ast.parse(source, filename=str(filepath))
+      except SyntaxError:
+        continue
+
+      for node in ast.walk(tree):
+        if not isinstance(node, ast.Call):
+          continue
+
+        # Check if this is a tyro.cli() call
+        func = node.func
+        is_tyro_cli = False
+
+        if isinstance(func, ast.Attribute) and func.attr == "cli":
+          # tyro.cli(...)
+          if isinstance(func.value, ast.Name) and func.value.id == "tyro":
+            is_tyro_cli = True
+        elif isinstance(func, ast.Name) and func.id == "cli":
+          # from tyro import cli; cli(...)
+          is_tyro_cli = True
+
+        if not is_tyro_cli:
+          continue
+
+        # Check if config= keyword argument contains TYRO_FLAGS
+        has_tyro_flags = False
+        for keyword in node.keywords:
+          if keyword.arg == "config":
+            config_source = ast.unparse(keyword.value)
+            if "TYRO_FLAGS" in config_source:
+              has_tyro_flags = True
+              break
+
+        results.append((filepath, node.lineno, has_tyro_flags))
+
+  return results
+
+
+def test_tyro_cli_calls_have_tyro_flags():
+  """Ensure all tyro.cli() calls include config=mjlab.TYRO_FLAGS."""
+  all_calls = find_tyro_cli_calls()
+  assert all_calls, "No tyro.cli() calls found"
+
+  violations = [
+    (filepath, line) for filepath, line, has_flags in all_calls if not has_flags
+  ]
+
+  if violations:
+    msg = "tyro.cli() calls missing config=mjlab.TYRO_FLAGS:\n"
+    for filepath, line in violations:
+      rel_path = filepath.relative_to(ROOT)
+      msg += f"  {rel_path}:{line}\n"
+    pytest.fail(msg)
diff --git a/tests/test_variants.py b/tests/test_variants.py
new file mode 100644
index 0000000..609ce88
--- /dev/null
+++ b/tests/test_variants.py
@@ -0,0 +1,1772 @@
+"""Tests for per-world mesh variant support."""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+import mujoco
+import numpy as np
+import pytest
+import torch
+
+from mjlab.entity import (
+  EntityCfg,
+  VariantEntityCfg,
+)
+from mjlab.entity.variants import (
+  SlotKey,
+  VariantGeomSpec,
+  VariantSlot,
+  allocate_worlds,
+  build_variant_model,
+)
+from mjlab.viewer.model_sync import (
+  disable_model_sameframe_shortcuts,
+  sync_model_fields,
+)
+
+# Helpers: variant specs with visual + collision mesh geoms.
+
+
+def _sphere_2col_spec() -> mujoco.MjSpec:
+  """Sphere: 1 visual + 2 collision geoms."""
+  spec = mujoco.MjSpec()
+  mv = spec.add_mesh()
+  mv.name = "visual"
+  mv.make_sphere(subdivision=3)
+  for i in range(2):
+    mc = spec.add_mesh()
+    mc.name = f"col_{i}"
+    mc.make_sphere(subdivision=1)
+  body = spec.worldbody.add_body()
+  body.name = "prop"
+  body.add_freejoint()
+  gv = body.add_geom()
+  gv.name = "visual"
+  gv.type = mujoco.mjtGeom.mjGEOM_MESH
+  gv.meshname = "visual"
+  gv.contype = 0
+  gv.conaffinity = 0
+  for i in range(2):
+    gc = body.add_geom()
+    gc.name = f"col_{i}"
+    gc.type = mujoco.mjtGeom.mjGEOM_MESH
+    gc.meshname = f"col_{i}"
+  return spec
+
+
+def _cone_4col_spec() -> mujoco.MjSpec:
+  """Cone: 1 visual + 4 collision geoms (more than sphere)."""
+  spec = mujoco.MjSpec()
+  mv = spec.add_mesh()
+  mv.name = "visual"
+  mv.make_cone(nedge=8, radius=0.05)
+  for i in range(4):
+    mc = spec.add_mesh()
+    mc.name = f"col_{i}"
+    mc.make_sphere(subdivision=1)
+  body = spec.worldbody.add_body()
+  body.name = "prop"
+  body.add_freejoint()
+  gv = body.add_geom()
+  gv.name = "visual"
+  gv.type = mujoco.mjtGeom.mjGEOM_MESH
+  gv.meshname = "visual"
+  gv.contype = 0
+  gv.conaffinity = 0
+  for i in range(4):
+    gc = body.add_geom()
+    gc.name = f"col_{i}"
+    gc.type = mujoco.mjtGeom.mjGEOM_MESH
+    gc.meshname = f"col_{i}"
+  return spec
+
+
+def _simple_sphere_spec() -> mujoco.MjSpec:
+  """Single-geom sphere for simple tests."""
+  spec = mujoco.MjSpec()
+  m = spec.add_mesh()
+  m.name = "sphere"
+  m.make_sphere(subdivision=2)
+  body = spec.worldbody.add_body()
+  body.name = "prop"
+  body.add_freejoint()
+  g = body.add_geom()
+  g.name = "visual"
+  g.type = mujoco.mjtGeom.mjGEOM_MESH
+  g.meshname = "sphere"
+  return spec
+
+
+def _simple_cone_spec() -> mujoco.MjSpec:
+  """Single-geom cone for simple tests."""
+  spec = mujoco.MjSpec()
+  m = spec.add_mesh()
+  m.name = "cone"
+  m.make_cone(nedge=8, radius=0.05)
+  body = spec.worldbody.add_body()
+  body.name = "prop"
+  body.add_freejoint()
+  g = body.add_geom()
+  g.name = "visual"
+  g.type = mujoco.mjtGeom.mjGEOM_MESH
+  g.meshname = "cone"
+  return spec
+
+
+def _hinge_spec() -> mujoco.MjSpec:
+  """Object with a hinge joint (incompatible with freejoint variants)."""
+  spec = mujoco.MjSpec()
+  m = spec.add_mesh()
+  m.name = "box"
+  m.make_sphere(subdivision=1)
+  body = spec.worldbody.add_body()
+  body.name = "prop"
+  j = body.add_joint()
+  j.name = "hinge"
+  j.type = mujoco.mjtJoint.mjJNT_HINGE
+  g = body.add_geom()
+  g.name = "visual"
+  g.type = mujoco.mjtGeom.mjGEOM_MESH
+  g.meshname = "box"
+  return spec
+
+
+def _build_scene_with_variants(
+  variant_a_fn, variant_b_fn, *, weight_a=0.5, weight_b=0.5
+):
+  """Build a scene spec + variant_info from two variant spec_fns."""
+  cfg = VariantEntityCfg(
+    variants={"a": variant_a_fn, "b": variant_b_fn},
+    assignment={"a": weight_a, "b": weight_b},
+  )
+  entity = cfg.build()
+  assert entity.variant_metadata is not None
+  scene_spec = mujoco.MjSpec()
+  frame = scene_spec.worldbody.add_frame()
+  scene_spec.attach(entity.spec, prefix="object/", frame=frame)
+  return scene_spec, [("object/", entity.variant_metadata)]
+
+
+# allocate_worlds.
+
+
+def test_allocate_worlds_proportional():
+  result = allocate_worlds((0.6, 0.4), 10)
+  assert len(result) == 10
+  assert result.count(0) == 6
+  assert result.count(1) == 4
+
+
+def test_allocate_worlds_uniform():
+  result = allocate_worlds((1.0, 1.0), 8)
+  assert result.count(0) == 4
+  assert result.count(1) == 4
+
+
+def test_allocate_worlds_single_variant():
+  result = allocate_worlds((1.0,), 5)
+  assert result == [0, 0, 0, 0, 0]
+
+
+def test_allocate_worlds_zero_weight_skips_variant():
+  """A zero-weight variant gets zero worlds; the rest split nworld."""
+  result = allocate_worlds((1.0, 0.0, 1.0), 10)
+  assert len(result) == 10
+  assert result.count(1) == 0
+  assert result.count(0) == 5
+  assert result.count(2) == 5
+
+
+def test_allocate_worlds_rejects_negative_weight():
+  with pytest.raises(ValueError, match="non-negative"):
+    allocate_worlds((1.0, -0.1), 10)
+
+
+def test_allocate_worlds_rejects_all_zero():
+  with pytest.raises(ValueError, match="positive sum"):
+    allocate_worlds((0.0, 0.0), 10)
+
+
+def test_allocate_worlds_largest_remainder_sums_to_nworld():
+  """Largest-remainder rounding must always allocate exactly nworld worlds."""
+  for nworld in (3, 7, 100, 1000):
+    result = allocate_worlds((1.0, 1.0, 1.0), nworld)
+    assert len(result) == nworld
+    # Difference between any two variant counts is at most 1 (uniform).
+    counts = [result.count(i) for i in range(3)]
+    assert max(counts) - min(counts) <= 1
+
+
+# assignment_fn override.
+
+
+def test_assignment_fn_overrides_weights():
+  """When assignment_fn is set, it dictates the per-world variant indices."""
+  cfg = VariantEntityCfg(
+    variants={
+      "sphere": _simple_sphere_spec,
+      "cone": _simple_cone_spec,  # ignored
+    },
+    assignment=lambda nworld: [0, 1, 0, 1] * (nworld // 4),
+  )
+  entity = cfg.build()
+  assert entity.variant_metadata is not None
+  scene_spec = mujoco.MjSpec()
+  frame = scene_spec.worldbody.add_frame()
+  scene_spec.attach(entity.spec, prefix="object/", frame=frame)
+  result = build_variant_model(scene_spec, 8, [("object/", entity.variant_metadata)])
+  w2v = result.world_to_variant["object/"]
+  assert list(w2v) == [0, 1, 0, 1, 0, 1, 0, 1]
+
+
+def test_assignment_fn_seeded_is_nworld_invariant():
+  """Per-world independent RNG draws make world W's variant a function of W
+  alone, independent of nworld."""
+  weights = (1.0, 2.0, 1.0)
+  cum = np.cumsum(np.asarray(weights) / sum(weights))
+
+  def seeded_assignment(seed: int):
+    def fn(nworld: int) -> list[int]:
+      return [
+        int(np.searchsorted(cum, np.random.default_rng((seed, w)).random()))
+        for w in range(nworld)
+      ]
+
+    return fn
+
+  fn_64 = seeded_assignment(seed=42)(64)
+  fn_256 = seeded_assignment(seed=42)(256)
+  # World 0..63 must agree across both batch sizes.
+  assert fn_64 == fn_256[:64]
+
+
+def test_assignment_fn_rejects_wrong_length():
+  cfg = VariantEntityCfg(
+    variants={
+      "sphere": _simple_sphere_spec,
+      "cone": _simple_cone_spec,
+    },
+    assignment=lambda nworld: [0] * (nworld - 1),  # one short
+  )
+  entity = cfg.build()
+  assert entity.variant_metadata is not None
+  scene_spec = mujoco.MjSpec()
+  frame = scene_spec.worldbody.add_frame()
+  scene_spec.attach(entity.spec, prefix="object/", frame=frame)
+  with pytest.raises(ValueError, match="returned .* indices but nworld="):
+    build_variant_model(scene_spec, 4, [("object/", entity.variant_metadata)])
+
+
+def test_assignment_fn_rejects_out_of_range_index():
+  cfg = VariantEntityCfg(
+    variants={
+      "sphere": _simple_sphere_spec,
+      "cone": _simple_cone_spec,
+    },
+    assignment=lambda nworld: [0, 1, 0, 99],  # 99 is out of range
+  )
+  entity = cfg.build()
+  assert entity.variant_metadata is not None
+  scene_spec = mujoco.MjSpec()
+  frame = scene_spec.worldbody.add_frame()
+  scene_spec.attach(entity.spec, prefix="object/", frame=frame)
+  with pytest.raises(ValueError, match="returned variant index 99"):
+    build_variant_model(scene_spec, 4, [("object/", entity.variant_metadata)])
+
+
+# Entity merging.
+
+
+def test_entity_builds_with_variants():
+  cfg = VariantEntityCfg(
+    variants={
+      "sphere": _simple_sphere_spec,
+      "cone": _simple_cone_spec,
+    },
+  )
+  entity = cfg.build()
+  meta = entity.variant_metadata
+  assert meta is not None
+  assert meta.variant_names == ("sphere", "cone")
+  assert meta.num_mesh_geoms == 1
+  mesh_names = [m.name for m in entity.spec.meshes]
+  assert any("sphere" in n for n in mesh_names)
+  assert any("cone" in n for n in mesh_names)
+
+
+def test_multi_geom_body_padding():
+  """Sphere (3 geoms) + cone (5 geoms) -> body padded to 5 mesh geoms."""
+  cfg = VariantEntityCfg(
+    variants={
+      "sphere": _sphere_2col_spec,
+      "cone": _cone_4col_spec,
+    },
+  )
+  entity = cfg.build()
+  meta = entity.variant_metadata
+  assert meta is not None
+  assert meta.num_mesh_geoms == 5  # max(3, 5)
+  # Sphere: 3 real + 2 padding (None).
+  assert sum(1 for n in meta.variant_mesh_names[0] if n is None) == 2
+  # Cone: 5 real, no padding.
+  assert all(n is not None for n in meta.variant_mesh_names[1])
+
+
+# Validation.
+
+
+def test_mismatched_joint_structure_raises():
+  cfg = VariantEntityCfg(
+    variants={
+      "sphere": _simple_sphere_spec,
+      "hinge": _hinge_spec,
+    },
+  )
+  with pytest.raises(ValueError, match="joint"):
+    cfg.build()
+
+
+def test_single_variant_builds():
+  """A single variant degenerates cleanly; useful for templated variant sets."""
+  cfg = VariantEntityCfg(
+    variants={"only": _simple_sphere_spec},
+  )
+  entity = cfg.build()
+  assert entity.variant_metadata is not None
+  assert entity.variant_metadata.variant_names == ("only",)
+
+
+def test_empty_variants_raises():
+  cfg = VariantEntityCfg(variants={})
+  with pytest.raises(ValueError, match="at least one"):
+    cfg.build()
+
+
+def _fixed_base_sphere_spec() -> mujoco.MjSpec:
+  """Fixed-base sphere variant (no free joint): currently unsupported."""
+  spec = mujoco.MjSpec()
+  m = spec.add_mesh(name="sphere")
+  m.make_sphere(subdivision=2)
+  body = spec.worldbody.add_body(name="prop")
+  body.add_geom(type=mujoco.mjtGeom.mjGEOM_MESH, meshname="sphere")
+  return spec
+
+
+def test_fixed_base_variants_rejected():
+  """Variants must be floating-base; fixed-base raises with a clear message."""
+  cfg = VariantEntityCfg(
+    variants={
+      "a": _fixed_base_sphere_spec,
+      "b": _fixed_base_sphere_spec,
+    },
+  )
+  with pytest.raises(ValueError, match="floating-base"):
+    cfg.build()
+
+
+def test_setting_spec_fn_on_variant_cfg_raises():
+  """VariantEntityCfg.spec_fn is unused; setting it should fail loudly."""
+  with pytest.raises(ValueError, match="spec_fn cannot be set"):
+    VariantEntityCfg(
+      variants={"only": _simple_sphere_spec},
+      spec_fn=_simple_sphere_spec,
+    )
+
+
+# Recursive validation: helpers and tests.
+
+
+def _articulated_spec(
+  *,
+  root_mesh: str = "root_mesh",
+  child_mesh: str = "child_mesh",
+  with_grandchild: bool = False,
+) -> mujoco.MjSpec:
+  """Root + child body (hinge joint). Optional grandchild for arity tests."""
+  spec = mujoco.MjSpec()
+  rm = spec.add_mesh(name=root_mesh)
+  rm.make_sphere(subdivision=2)
+  cm = spec.add_mesh(name=child_mesh)
+  cm.make_sphere(subdivision=2)
+  root = spec.worldbody.add_body(name="prop")
+  root.add_freejoint()
+  rg = root.add_geom()
+  rg.name = "root_geom"
+  rg.type = mujoco.mjtGeom.mjGEOM_MESH
+  rg.meshname = root_mesh
+  child = root.add_body(name="lid")
+  cj = child.add_joint()
+  cj.name = "hinge"
+  cj.type = mujoco.mjtJoint.mjJNT_HINGE
+  cg = child.add_geom()
+  cg.name = "child_geom"
+  cg.type = mujoco.mjtGeom.mjGEOM_MESH
+  cg.meshname = child_mesh
+  if with_grandchild:
+    gm = spec.add_mesh(name="grand_mesh")
+    gm.make_sphere(subdivision=2)
+    grand = child.add_body(name="grand")
+    grand.add_geom(
+      name="grand_geom", type=mujoco.mjtGeom.mjGEOM_MESH, meshname="grand_mesh"
+    )
+  return spec
+
+
+def _spec_with_actuator(actuator_name: str = "act") -> mujoco.MjSpec:
+  """Single-body sphere with a hinge child + a position actuator."""
+  spec = mujoco.MjSpec()
+  m = spec.add_mesh(name="sphere")
+  m.make_sphere(subdivision=2)
+  root = spec.worldbody.add_body(name="prop")
+  root.add_freejoint()
+  root.add_geom(name="visual", type=mujoco.mjtGeom.mjGEOM_MESH, meshname="sphere")
+  child = root.add_body(name="lid")
+  cj = child.add_joint()
+  cj.name = "hinge"
+  cj.type = mujoco.mjtJoint.mjJNT_HINGE
+  child.add_geom(name="lid_geom", type=mujoco.mjtGeom.mjGEOM_MESH, meshname="sphere")
+  act = spec.add_actuator()
+  act.name = actuator_name
+  act.set_to_motor()
+  act.target = "hinge"
+  return spec
+
+
+def _spec_with_primitive(primitive_role: str = "collision") -> mujoco.MjSpec:
+  """Sphere variant with an additional primitive box (visual or collision)."""
+  spec = mujoco.MjSpec()
+  m = spec.add_mesh(name="sphere")
+  m.make_sphere(subdivision=2)
+  body = spec.worldbody.add_body(name="prop")
+  body.add_freejoint()
+  box = body.add_geom()
+  box.name = "primitive"
+  box.type = mujoco.mjtGeom.mjGEOM_BOX
+  box.size = np.array([0.05, 0.05, 0.05])
+  if primitive_role == "visual":
+    box.contype = 0
+    box.conaffinity = 0
+  body.add_geom(name="mesh_geom", type=mujoco.mjtGeom.mjGEOM_MESH, meshname="sphere")
+  return spec
+
+
+def _spec_with_diagonal_inertia() -> mujoco.MjSpec:
+  spec = _simple_sphere_spec()
+  body = list(spec.worldbody.bodies)[0]
+  body.explicitinertial = True
+  body.mass = 1.0
+  body.ipos = np.array([0.0, 0.0, 0.0])
+  body.inertia = np.array([0.001, 0.001, 0.001])
+  body.iquat = np.array([1.0, 0.0, 0.0, 0.0])
+  return spec
+
+
+def _spec_with_fullinertia() -> mujoco.MjSpec:
+  spec = _simple_sphere_spec()
+  body = list(spec.worldbody.bodies)[0]
+  body.explicitinertial = True
+  body.mass = 1.0
+  body.ipos = np.array([0.0, 0.0, 0.0])
+  body.fullinertia = np.array([0.001, 0.001, 0.001, 0.0, 0.0, 0.0])
+  return spec
+
+
+def _spec_with_reserved_mesh_name() -> mujoco.MjSpec:
+  spec = mujoco.MjSpec()
+  m = spec.add_mesh(name="mjlab/pad/sneaky")
+  m.make_sphere(subdivision=2)
+  body = spec.worldbody.add_body(name="prop")
+  body.add_freejoint()
+  body.add_geom(
+    name="visual", type=mujoco.mjtGeom.mjGEOM_MESH, meshname="mjlab/pad/sneaky"
+  )
+  return spec
+
+
+def test_articulated_same_topology_validates():
+  """Articulated variants with matching topology pass validation
+  (build still rejects via floating-base check; this verifies validation
+  itself does not complain)."""
+  cfg = VariantEntityCfg(
+    variants={
+      "a": lambda: _articulated_spec(root_mesh="r_a", child_mesh="c_a"),
+      "b": lambda: _articulated_spec(root_mesh="r_b", child_mesh="c_b"),
+    },
+  )
+  entity = cfg.build()
+  assert entity.variant_metadata is not None
+
+
+def test_recursive_child_body_count_mismatch_rejected():
+  """Variants with different grandchild counts fail recursive validation."""
+  cfg = VariantEntityCfg(
+    variants={
+      "shallow": lambda: _articulated_spec(with_grandchild=False),
+      "deep": lambda: _articulated_spec(with_grandchild=True),
+    },
+  )
+  with pytest.raises(ValueError, match="child bodies"):
+    cfg.build()
+
+
+def test_recursive_child_body_name_mismatch_rejected():
+  def variant_lid():
+    return _articulated_spec()
+
+  def variant_renamed_child():
+    spec = _articulated_spec()
+    list(spec.worldbody.bodies)[0].bodies[0].name = "drawer_top"
+    return spec
+
+  cfg = VariantEntityCfg(
+    variants={
+      "lid": variant_lid,
+      "drawer": variant_renamed_child,
+    },
+  )
+  with pytest.raises(ValueError, match="body path"):
+    cfg.build()
+
+
+def test_recursive_joint_mismatch_in_child_body_rejected():
+  def variant_a():
+    return _articulated_spec()
+
+  def variant_b_slide():
+    spec = _articulated_spec()
+    child = list(spec.worldbody.bodies)[0].bodies[0]
+    list(child.joints)[0].type = mujoco.mjtJoint.mjJNT_SLIDE
+    return spec
+
+  cfg = VariantEntityCfg(
+    variants={
+      "hinge": variant_a,
+      "slide": variant_b_slide,
+    },
+  )
+  with pytest.raises(ValueError, match="joint"):
+    cfg.build()
+
+
+def test_primitive_geom_count_mismatch_rejected():
+  cfg = VariantEntityCfg(
+    variants={
+      "with_box": _spec_with_primitive,
+      "without_box": _simple_sphere_spec,
+    },
+  )
+  with pytest.raises(ValueError, match="non-mesh geoms"):
+    cfg.build()
+
+
+def test_primitive_geom_role_mismatch_rejected():
+  cfg = VariantEntityCfg(
+    variants={
+      "col": lambda: _spec_with_primitive("collision"),
+      "vis": lambda: _spec_with_primitive("visual"),
+    },
+  )
+  with pytest.raises(ValueError, match="primitive geom"):
+    cfg.build()
+
+
+def test_actuator_count_mismatch_rejected():
+  cfg = VariantEntityCfg(
+    variants={
+      "no_act": _articulated_spec,
+      "with_act": _spec_with_actuator,
+    },
+  )
+  with pytest.raises(ValueError, match="actuator count"):
+    cfg.build()
+
+
+def test_actuator_name_mismatch_rejected():
+  cfg = VariantEntityCfg(
+    variants={
+      "act_a": lambda: _spec_with_actuator("motor_a"),
+      "act_b": lambda: _spec_with_actuator("motor_b"),
+    },
+  )
+  with pytest.raises(ValueError, match="actuator #0"):
+    cfg.build()
+
+
+def test_fullinertia_diagonal_mixing_rejected():
+  cfg = VariantEntityCfg(
+    variants={
+      "diag": _spec_with_diagonal_inertia,
+      "full": _spec_with_fullinertia,
+    },
+  )
+  with pytest.raises(ValueError, match="inertial representation"):
+    cfg.build()
+
+
+def test_diagonal_inertia_consistent_accepted():
+  cfg = VariantEntityCfg(
+    variants={
+      "a": _spec_with_diagonal_inertia,
+      "b": _spec_with_diagonal_inertia,
+    },
+  )
+  entity = cfg.build()
+  assert entity.variant_metadata is not None
+
+
+def test_reserved_prefix_in_mesh_rejected():
+  cfg = VariantEntityCfg(
+    variants={
+      "good": _simple_sphere_spec,
+      "bad": _spec_with_reserved_mesh_name,
+    },
+  )
+  with pytest.raises(ValueError, match="reserved name prefix"):
+    cfg.build()
+
+
+def test_validation_error_format():
+  """Error messages use the standardized mjlab.entity prefix and Hint suffix."""
+  cfg = VariantEntityCfg(
+    variants={
+      "ok": _simple_sphere_spec,
+      "bad": _hinge_spec,
+    },
+  )
+  with pytest.raises(ValueError) as excinfo:
+    cfg.build()
+  msg = str(excinfo.value)
+  assert msg.startswith("mjlab.entity: VariantEntityCfg 'bad': ")
+  assert "Hint:" in msg
+
+
+def _spec_with_sensor() -> mujoco.MjSpec:
+  """Sphere with a free joint and a velocity sensor on it."""
+  spec = _simple_sphere_spec()
+  s = spec.add_sensor()
+  s.name = "vel"
+  s.type = mujoco.mjtSensor.mjSENS_VELOCIMETER
+  s.objtype = mujoco.mjtObj.mjOBJ_SITE
+  s.objname = "site_a"
+  # Sensor needs a site target; add one.
+  body = list(spec.worldbody.bodies)[0]
+  site = body.add_site()
+  site.name = "site_a"
+  return spec
+
+
+def test_sensor_count_mismatch_rejected():
+  cfg = VariantEntityCfg(
+    variants={
+      "no_sens": _simple_sphere_spec,
+      "with_sens": _spec_with_sensor,
+    },
+  )
+  with pytest.raises(ValueError, match="sensor count"):
+    cfg.build()
+
+
+def test_validate_specs_directly_rejects_zero_root_bodies():
+  """Empty worldbody fails with a clear root-body message."""
+  from mjlab.entity.variants import validate_variant_specs
+
+  empty = mujoco.MjSpec()
+  ok = _simple_sphere_spec()
+  with pytest.raises(ValueError, match="exactly one root body"):
+    validate_variant_specs(["empty", "ok"], [empty, ok])
+
+
+# Slot metadata (Workstream 3).
+
+
+def _slot_is_padding(meta, slot_index: int) -> bool:
+  """True if any variant leaves the slot at ``slot_index`` unfilled."""
+  return any(specs[slot_index] is None for specs in meta.variant_slot_specs)
+
+
+def test_slot_metadata_single_variant_single_geom():
+  cfg = VariantEntityCfg(variants={"only": _simple_sphere_spec})
+  meta = cfg.build().variant_metadata
+  assert meta is not None
+  assert len(meta.slots) == 1
+  slot = meta.slots[0]
+  assert isinstance(slot, VariantSlot)
+  assert slot.key == SlotKey(body_path="/prop", role="collision", ordinal=0)
+  assert _slot_is_padding(meta, 0) is False
+  assert slot.template_geom_name == "mjlab/pad/prop/collision/0"
+  # source_geom_names has one entry per variant.
+  assert slot.source_geom_names == ("visual",)
+  # variant_slot_specs aligns with slots.
+  assert len(meta.variant_slot_specs) == 1
+  assert len(meta.variant_slot_specs[0]) == 1
+  vgs = meta.variant_slot_specs[0][0]
+  assert isinstance(vgs, VariantGeomSpec)
+  assert vgs.geom_name == "visual"
+  assert vgs.mesh_name == "sphere"
+
+
+def test_slot_metadata_visual_collision_split():
+  """Visual and collision geoms on the same body get distinct slots."""
+  cfg = VariantEntityCfg(
+    variants={
+      "sphere": _sphere_2col_spec,
+      "cone": _cone_4col_spec,
+    }
+  )
+  meta = cfg.build().variant_metadata
+  assert meta is not None
+  # Body /prop has 1 visual + max(2, 4) = 4 collision slots.
+  visual_slots = [s for s in meta.slots if s.key.role == "visual"]
+  collision_slots = [s for s in meta.slots if s.key.role == "collision"]
+  assert len(visual_slots) == 1
+  assert len(collision_slots) == 4
+  assert all(s.key.body_path == "/prop" for s in meta.slots)
+
+
+def test_slot_metadata_visual_before_collision():
+  """Slot ordering: visual slots come before collision slots per body."""
+  cfg = VariantEntityCfg(
+    variants={
+      "sphere": _sphere_2col_spec,
+      "cone": _cone_4col_spec,
+    }
+  )
+  meta = cfg.build().variant_metadata
+  assert meta is not None
+  roles = [s.key.role for s in meta.slots]
+  # Find first collision; all visual should come before it.
+  first_col = roles.index("collision")
+  assert all(r == "visual" for r in roles[:first_col])
+  assert all(r == "collision" for r in roles[first_col:])
+
+
+def test_slot_metadata_padding_derivable_from_specs():
+  """A slot held by some variants but not others is unfilled (None) for those."""
+  cfg = VariantEntityCfg(
+    variants={
+      "sphere": _sphere_2col_spec,
+      "cone": _cone_4col_spec,
+    }
+  )
+  meta = cfg.build().variant_metadata
+  assert meta is not None
+  col_positions = [i for i, s in enumerate(meta.slots) if s.key.role == "collision"]
+  # Sphere has 2 collision; cone has 4. Slots 0, 1 fully populated; 2, 3 are padding.
+  assert _slot_is_padding(meta, col_positions[0]) is False
+  assert _slot_is_padding(meta, col_positions[1]) is False
+  assert _slot_is_padding(meta, col_positions[2]) is True
+  assert _slot_is_padding(meta, col_positions[3]) is True
+  # Sphere has None at the padding slots.
+  variant_idx_sphere = meta.variant_names.index("sphere")
+  specs_sphere = meta.variant_slot_specs[variant_idx_sphere]
+  assert specs_sphere[col_positions[2]] is None
+  assert specs_sphere[col_positions[3]] is None
+  # Cone has VariantGeomSpec for all collision slots.
+  variant_idx_cone = meta.variant_names.index("cone")
+  specs_cone = meta.variant_slot_specs[variant_idx_cone]
+  for cp in col_positions:
+    assert specs_cone[cp] is not None
+
+
+def test_slot_metadata_articulated_per_body_slots():
+  """Articulated variants produce slots per (body, role)."""
+  cfg = VariantEntityCfg(
+    variants={
+      "a": lambda: _articulated_spec(root_mesh="ar", child_mesh="ac"),
+      "b": lambda: _articulated_spec(root_mesh="br", child_mesh="bc"),
+    }
+  )
+  meta = cfg.build().variant_metadata
+  assert meta is not None
+  # Two bodies (/prop, /prop/lid), each with 1 collision mesh -> 2 slots.
+  paths = sorted({s.key.body_path for s in meta.slots})
+  assert paths == ["/prop", "/prop/lid"]
+  # Each body has exactly one collision slot, no visuals.
+  for path in paths:
+    body_slots = [s for s in meta.slots if s.key.body_path == path]
+    assert len(body_slots) == 1
+    assert body_slots[0].key.role == "collision"
+    slot_idx = meta.slots.index(body_slots[0])
+    assert _slot_is_padding(meta, slot_idx) is False
+  # Mesh names captured per variant per slot.
+  variant_a_specs = meta.variant_slot_specs[meta.variant_names.index("a")]
+  variant_b_specs = meta.variant_slot_specs[meta.variant_names.index("b")]
+  a_meshes = sorted(s.mesh_name for s in variant_a_specs if s is not None)
+  b_meshes = sorted(s.mesh_name for s in variant_b_specs if s is not None)
+  assert a_meshes == ["ac", "ar"]
+  assert b_meshes == ["bc", "br"]
+
+
+def test_slot_metadata_template_name_under_reserved_prefix():
+  """Every template slot name starts with the reserved mjlab/pad/ prefix."""
+  cfg = VariantEntityCfg(
+    variants={
+      "a": _simple_sphere_spec,
+      "b": _simple_cone_spec,
+    }
+  )
+  meta = cfg.build().variant_metadata
+  assert meta is not None
+  for slot in meta.slots:
+    assert slot.template_geom_name.startswith("mjlab/pad/")
+
+
+def test_slot_metadata_captures_visual_role_from_zero_contact_bits():
+  """A geom with contype=0 and conaffinity=0 is classified as visual."""
+  cfg = VariantEntityCfg(
+    variants={
+      "sphere": _sphere_2col_spec,
+      "cone": _cone_4col_spec,
+    }
+  )
+  meta = cfg.build().variant_metadata
+  assert meta is not None
+  visual_slots = [s for s in meta.slots if s.key.role == "visual"]
+  assert len(visual_slots) == 1
+  visual_slot = visual_slots[0]
+  for variant_specs in meta.variant_slot_specs:
+    spec_at_visual = variant_specs[meta.slots.index(visual_slot)]
+    assert spec_at_visual is not None
+    assert spec_at_visual.contype == 0
+    assert spec_at_visual.conaffinity == 0
+
+
+def test_slot_metadata_ordinals_are_zero_based_per_body_and_role():
+  """Within a (body, role), slot ordinals are 0..max-1."""
+  cfg = VariantEntityCfg(
+    variants={
+      "sphere": _sphere_2col_spec,
+      "cone": _cone_4col_spec,
+    }
+  )
+  meta = cfg.build().variant_metadata
+  assert meta is not None
+  collision_slots = [s for s in meta.slots if s.key.role == "collision"]
+  assert [s.key.ordinal for s in collision_slots] == [0, 1, 2, 3]
+  visual_slots = [s for s in meta.slots if s.key.role == "visual"]
+  assert [s.key.ordinal for s in visual_slots] == [0]
+
+
+def test_slot_metadata_alignment_invariant():
+  """variant_slot_specs[v] aligns with slots positionally for every variant."""
+  cfg = VariantEntityCfg(
+    variants={
+      "sphere": _sphere_2col_spec,
+      "cone": _cone_4col_spec,
+    }
+  )
+  meta = cfg.build().variant_metadata
+  assert meta is not None
+  for variant_specs in meta.variant_slot_specs:
+    assert len(variant_specs) == len(meta.slots)
+
+
+def test_template_geom_contype_matches_slot_role():
+  """Template contype/conaffinity are derived from slot role (union of variants)."""
+  scene_spec, vi = _build_scene_with_variants(_sphere_2col_spec, _cone_4col_spec)
+  result = build_variant_model(scene_spec, 4, vi)
+  metadata = vi[0][1]
+  for slot in metadata.slots:
+    full_name = f"object/{slot.template_geom_name}"
+    gid = mujoco.mj_name2id(result.mj_model, mujoco.mjtObj.mjOBJ_GEOM, full_name)
+    assert gid >= 0, f"slot geom '{full_name}' missing from compiled model"
+    contype = int(result.mj_model.geom_contype[gid])
+    conaffinity = int(result.mj_model.geom_conaffinity[gid])
+    if slot.key.role == "visual":
+      assert contype == 0, f"visual slot {slot.key} has contype={contype}"
+      assert conaffinity == 0, f"visual slot {slot.key} has conaffinity={conaffinity}"
+    else:
+      assert contype == 1, f"collision slot {slot.key} has contype={contype}"
+      assert conaffinity == 1, (
+        f"collision slot {slot.key} has conaffinity={conaffinity}"
+      )
+
+
+def test_template_geoms_use_mjlab_pad_prefix():
+  """All entity mesh-geom names in the compiled template use mjlab/pad/ prefix."""
+  scene_spec, vi = _build_scene_with_variants(_sphere_2col_spec, _cone_4col_spec)
+  result = build_variant_model(scene_spec, 4, vi)
+  for gid in range(result.mj_model.ngeom):
+    if result.mj_model.geom_type[gid] != mujoco.mjtGeom.mjGEOM_MESH:
+      continue
+    name = mujoco.mj_id2name(result.mj_model, mujoco.mjtObj.mjOBJ_GEOM, gid) or ""
+    if not name.startswith("object/"):
+      continue
+    suffix = name[len("object/") :]
+    assert suffix.startswith("mjlab/pad/"), (
+      f"entity mesh geom '{name}' does not use mjlab/pad/ prefix"
+    )
+
+
+def test_visual_collision_split_inertia_matches_independent_compile():
+  """Per-world body_mass matches independent compile when variants have visual+collision split.
+
+  This verifies the slot-driven reference compile preserves the visual
+  role (contype=0/conaffinity=0) on the visual mesh; if the old
+  contype=1/conaffinity=1 reset still ran, the visual mesh's
+  inertia-inference behavior would not change for default groups, but
+  this exercise pins the contract end-to-end.
+  """
+  scene_spec, vi = _build_scene_with_variants(_sphere_2col_spec, _cone_4col_spec)
+  result = build_variant_model(scene_spec, 4, vi)
+
+  sphere_model = _sphere_2col_spec().compile()
+  cone_model = _cone_4col_spec().compile()
+
+  body_mass = result.wp_model.body_mass.numpy()
+  w2v = result.world_to_variant["object/"]
+  obj_body = result.mj_model.nbody - 1
+
+  sphere_w = int(np.where(w2v == 0)[0][0])
+  cone_w = int(np.where(w2v == 1)[0][0])
+
+  np.testing.assert_allclose(
+    body_mass[sphere_w, obj_body],
+    sphere_model.body_mass[-1],
+    atol=1e-4,
+  )
+  np.testing.assert_allclose(
+    body_mass[cone_w, obj_body],
+    cone_model.body_mass[-1],
+    atol=1e-4,
+  )
+
+
+def test_variant_order_irrelevant_per_variant_compile():
+  """Reordering the variant dict does not change per-variant per-world fields."""
+  cfg_ab = VariantEntityCfg(
+    variants={
+      "a": _simple_sphere_spec,
+      "b": _simple_cone_spec,
+    }
+  )
+  cfg_ba = VariantEntityCfg(
+    variants={
+      "b": _simple_cone_spec,
+      "a": _simple_sphere_spec,
+    }
+  )
+
+  def _build_scene(cfg: VariantEntityCfg):
+    entity = cfg.build()
+    assert entity.variant_metadata is not None
+    scene_spec = mujoco.MjSpec()
+    frame = scene_spec.worldbody.add_frame()
+    scene_spec.attach(entity.spec, prefix="object/", frame=frame)
+    return scene_spec, [("object/", entity.variant_metadata)]
+
+  scene_ab, vi_ab = _build_scene(cfg_ab)
+  scene_ba, vi_ba = _build_scene(cfg_ba)
+  res_ab = build_variant_model(scene_ab, 4, vi_ab)
+  res_ba = build_variant_model(scene_ba, 4, vi_ba)
+
+  obj_body_ab = res_ab.mj_model.nbody - 1
+  obj_body_ba = res_ba.mj_model.nbody - 1
+
+  body_mass_ab = res_ab.wp_model.body_mass.numpy()
+  body_mass_ba = res_ba.wp_model.body_mass.numpy()
+
+  # In cfg_ab, "a" is variant index 0; in cfg_ba, "a" is variant index 1.
+  w2v_ab = res_ab.world_to_variant["object/"]
+  w2v_ba = res_ba.world_to_variant["object/"]
+  a_world_ab = int(np.where(w2v_ab == 0)[0][0])
+  a_world_ba = int(np.where(w2v_ba == 1)[0][0])
+  b_world_ab = int(np.where(w2v_ab == 1)[0][0])
+  b_world_ba = int(np.where(w2v_ba == 0)[0][0])
+
+  np.testing.assert_allclose(
+    body_mass_ab[a_world_ab, obj_body_ab],
+    body_mass_ba[a_world_ba, obj_body_ba],
+    atol=1e-5,
+    err_msg="variant 'a' body_mass differs across orderings",
+  )
+  np.testing.assert_allclose(
+    body_mass_ab[b_world_ab, obj_body_ab],
+    body_mass_ba[b_world_ba, obj_body_ba],
+    atol=1e-5,
+    err_msg="variant 'b' body_mass differs across orderings",
+  )
+
+
+def test_slot_metadata_source_geom_names_record_padding_as_none():
+  """source_geom_names has None where a variant doesn't fill a slot."""
+  cfg = VariantEntityCfg(
+    variants={
+      "sphere": _sphere_2col_spec,
+      "cone": _cone_4col_spec,
+    }
+  )
+  meta = cfg.build().variant_metadata
+  assert meta is not None
+  sphere_idx = meta.variant_names.index("sphere")
+  collision_slots = [s for s in meta.slots if s.key.role == "collision"]
+  # Sphere has 2 collision -> ordinals 2, 3 are None for sphere.
+  assert collision_slots[2].source_geom_names[sphere_idx] is None
+  assert collision_slots[3].source_geom_names[sphere_idx] is None
+  # Cone fills all 4.
+  cone_idx = meta.variant_names.index("cone")
+  for cs in collision_slots:
+    assert cs.source_geom_names[cone_idx] is not None
+
+
+def test_no_variants_unchanged():
+  cfg = EntityCfg(spec_fn=_simple_sphere_spec)
+  entity = cfg.build()
+  assert entity.variant_metadata is None
+
+
+# build_variant_model: dataid and dependent fields.
+
+
+def test_dataid_assigned_per_world():
+  """Each world's geom_dataid points to its variant's meshes."""
+  scene_spec, vi = _build_scene_with_variants(_simple_sphere_spec, _simple_cone_spec)
+  result = build_variant_model(scene_spec, 4, vi)
+
+  dataid = result.wp_model.geom_dataid.numpy()
+  assert dataid.shape == (4, result.mj_model.ngeom)
+  assert dataid.ndim == 2
+
+  w2v = result.world_to_variant["object/"]
+  assert w2v[0] == 0  # variant a (sphere)
+  assert w2v[2] == 1  # variant b (cone)
+
+  # Sphere and cone worlds must have different dataid values.
+  assert not np.array_equal(dataid[0], dataid[2])
+
+
+def _sphere_with_material_spec() -> mujoco.MjSpec:
+  """Single-geom sphere whose visual references a named material."""
+  spec = mujoco.MjSpec()
+  m = spec.add_mesh()
+  m.name = "sphere"
+  m.make_sphere(subdivision=2)
+  mat = spec.add_material()
+  mat.name = "red_mat"
+  mat.rgba[:] = (1.0, 0.0, 0.0, 1.0)
+  body = spec.worldbody.add_body()
+  body.name = "prop"
+  body.add_freejoint()
+  g = body.add_geom()
+  g.name = "visual"
+  g.type = mujoco.mjtGeom.mjGEOM_MESH
+  g.meshname = "sphere"
+  g.material = "red_mat"
+  return spec
+
+
+def _cone_with_material_spec() -> mujoco.MjSpec:
+  """Single-geom cone whose visual references a different named material."""
+  spec = mujoco.MjSpec()
+  m = spec.add_mesh()
+  m.name = "cone"
+  m.make_cone(nedge=8, radius=0.05)
+  mat = spec.add_material()
+  mat.name = "blue_mat"
+  mat.rgba[:] = (0.0, 0.0, 1.0, 1.0)
+  body = spec.worldbody.add_body()
+  body.name = "prop"
+  body.add_freejoint()
+  g = body.add_geom()
+  g.name = "visual"
+  g.type = mujoco.mjtGeom.mjGEOM_MESH
+  g.meshname = "cone"
+  g.material = "blue_mat"
+  return spec
+
+
+def test_materials_merged_under_variant_prefix():
+  """Both variants' materials end up in the merged spec, name-prefixed."""
+  scene_spec, vi = _build_scene_with_variants(
+    _sphere_with_material_spec, _cone_with_material_spec
+  )
+  model = scene_spec.compile()
+  mat_names = {model.material(i).name for i in range(model.nmat)}
+  assert "object/a/red_mat" in mat_names
+  assert "object/b/blue_mat" in mat_names
+
+
+def test_matid_assigned_per_world():
+  """Each world's geom_matid points to its variant's material."""
+  scene_spec, vi = _build_scene_with_variants(
+    _sphere_with_material_spec, _cone_with_material_spec
+  )
+  result = build_variant_model(scene_spec, 4, vi)
+
+  matid = result.wp_model.geom_matid.numpy()
+  assert matid.shape == (4, result.mj_model.ngeom)
+
+  w2v = result.world_to_variant["object/"]
+  red_id = mujoco.mj_name2id(
+    result.mj_model, mujoco.mjtObj.mjOBJ_MATERIAL, "object/a/red_mat"
+  )
+  blue_id = mujoco.mj_name2id(
+    result.mj_model, mujoco.mjtObj.mjOBJ_MATERIAL, "object/b/blue_mat"
+  )
+  assert red_id >= 0 and blue_id >= 0 and red_id != blue_id
+
+  # Slot geom is the last mesh geom (single-geom variants -> ordinal 0).
+  slot_gid = next(
+    gid
+    for gid in range(result.mj_model.ngeom - 1, -1, -1)
+    if result.mj_model.geom_type[gid] == mujoco.mjtGeom.mjGEOM_MESH
+  )
+
+  for w in range(4):
+    expected = red_id if w2v[w] == 0 else blue_id
+    assert int(matid[w, slot_gid]) == expected
+
+
+def test_matid_minus_one_when_variant_has_no_material():
+  """A variant slot without a material yields geom_matid == -1 in its worlds."""
+  scene_spec, vi = _build_scene_with_variants(
+    _sphere_with_material_spec,
+    _simple_cone_spec,  # cone has no material
+  )
+  result = build_variant_model(scene_spec, 4, vi)
+
+  matid = result.wp_model.geom_matid.numpy()
+  w2v = result.world_to_variant["object/"]
+  slot_gid = next(
+    gid
+    for gid in range(result.mj_model.ngeom - 1, -1, -1)
+    if result.mj_model.geom_type[gid] == mujoco.mjtGeom.mjGEOM_MESH
+  )
+  cone_world = int(np.where(w2v == 1)[0][0])
+  assert int(matid[cone_world, slot_gid]) == -1
+
+
+def test_padding_slots_get_disabled():
+  """Shorter variant's padding geom slots have dataid == -1."""
+  scene_spec, vi = _build_scene_with_variants(_sphere_2col_spec, _cone_4col_spec)
+  result = build_variant_model(scene_spec, 4, vi)
+
+  dataid = result.wp_model.geom_dataid.numpy()
+  w2v = result.world_to_variant["object/"]
+
+  # Find a sphere world (variant 0, 3 mesh geoms -> 2 padding slots).
+  sphere_world = int(np.where(w2v == 0)[0][0])
+  # Find mesh geom columns (skip non-mesh geoms like worldbody).
+  mesh_geom_ids = [
+    gid
+    for gid in range(result.mj_model.ngeom)
+    if result.mj_model.geom_type[gid] == mujoco.mjtGeom.mjGEOM_MESH
+  ]
+  sphere_dataid = dataid[sphere_world, mesh_geom_ids]
+  # Last 2 mesh geom slots should be -1 (disabled padding).
+  assert sphere_dataid[-1] == -1
+  assert sphere_dataid[-2] == -1
+  # Padding slots must still be collision-enabled in the template/warp model.
+  # Short variants are disabled by per-world dataid=-1; long variants need the
+  # same slots enabled so their extra hulls can collide.
+  assert np.all(result.mj_model.geom_contype[mesh_geom_ids[-2:]] == 1)
+  assert np.all(result.mj_model.geom_conaffinity[mesh_geom_ids[-2:]] == 1)
+  assert np.all(result.wp_model.geom_contype.numpy()[mesh_geom_ids[-2:]] == 1)
+  assert np.all(result.wp_model.geom_conaffinity.numpy()[mesh_geom_ids[-2:]] == 1)
+  # First 3 should be valid (>= 0).
+  assert all(d >= 0 for d in sphere_dataid[:3])
+
+
+def test_dependent_fields_match_individual_compilation():
+  """Per-world body_mass matches independently compiled variant models."""
+  scene_spec, vi = _build_scene_with_variants(_simple_sphere_spec, _simple_cone_spec)
+  result = build_variant_model(scene_spec, 4, vi)
+
+  # Compile each variant independently for reference values.
+  sphere_model = _simple_sphere_spec().compile()
+  cone_model = _simple_cone_spec().compile()
+
+  body_mass = result.wp_model.body_mass.numpy()
+  w2v = result.world_to_variant["object/"]
+
+  sphere_w = int(np.where(w2v == 0)[0][0])
+  cone_w = int(np.where(w2v == 1)[0][0])
+
+  # The object body is the last body in the scene.
+  obj_body = result.mj_model.nbody - 1
+
+  # Mass should match individually compiled models.
+  np.testing.assert_allclose(
+    body_mass[sphere_w, obj_body],
+    sphere_model.body_mass[-1],
+    atol=1e-4,
+  )
+  np.testing.assert_allclose(
+    body_mass[cone_w, obj_body],
+    cone_model.body_mass[-1],
+    atol=1e-4,
+  )
+
+  # Sphere and cone should have different masses.
+  assert not np.isclose(body_mass[sphere_w, obj_body], body_mass[cone_w, obj_body])
+
+
+def test_select_default_values_uses_per_world_variant_defaults():
+  """Per-world defaults are indexed by env first, then by entity."""
+  from mjlab.envs import ManagerBasedRlEnv, ManagerBasedRlEnvCfg
+  from mjlab.envs.mdp.dr._core import _select_default_values
+  from mjlab.scene import SceneCfg
+  from mjlab.terrains import TerrainEntityCfg
+
+  def _explicit_variant(
+    mesh_name: str,
+    mass: float,
+    inertia: tuple[float, float, float],
+    *,
+    cone: bool = False,
+  ) -> mujoco.MjSpec:
+    spec = mujoco.MjSpec()
+    mesh = spec.add_mesh()
+    mesh.name = mesh_name
+    if cone:
+      mesh.make_cone(nedge=8, radius=0.05)
+    else:
+      mesh.make_sphere(subdivision=1)
+    body = spec.worldbody.add_body(name="prop")
+    body.add_freejoint()
+    body.explicitinertial = True
+    body.mass = mass
+    body.ipos[:] = (0.0, 0.0, 0.0)
+    body.inertia[:] = inertia
+    body.iquat[:] = (1.0, 0.0, 0.0, 0.0)
+    body.add_geom(
+      name="visual",
+      type=mujoco.mjtGeom.mjGEOM_MESH,
+      meshname=mesh_name,
+      contype=0,
+      conaffinity=0,
+      mass=0.0,
+    )
+    return spec
+
+  object_cfg = VariantEntityCfg(
+    variants={
+      "sphere": lambda: _explicit_variant("sphere", 0.2, (1e-4, 2e-4, 3e-4)),
+      "cone": lambda: _explicit_variant("cone", 0.7, (4e-4, 5e-4, 6e-4), cone=True),
+    },
+    init_state=EntityCfg.InitialStateCfg(pos=(0.0, 0.0, 0.2)),
+  )
+  env_cfg = ManagerBasedRlEnvCfg(
+    decimation=1,
+    scene=SceneCfg(
+      terrain=TerrainEntityCfg(terrain_type="plane"),
+      num_envs=4,
+      env_spacing=1.0,
+      entities={"object": object_cfg},
+    ),
+  )
+
+  env = ManagerBasedRlEnv(cfg=env_cfg, device="cpu")
+  try:
+    obj_body = int(env.scene["object"].indexing.root_body_id)
+    env_ids = torch.arange(env.num_envs, device=env.device)
+    body_ids = torch.tensor([obj_body], device=env.device)
+
+    for field in ("body_mass", "body_ipos", "body_inertia", "body_iquat"):
+      selected = _select_default_values(env, field, env_ids, body_ids)
+      torch.testing.assert_close(
+        selected[:, 0],
+        getattr(env.sim.model, field)[:, obj_body],
+      )
+  finally:
+    env.close()
+
+
+def test_viser_builds_per_world_mesh_handles_for_variants():
+  """Viser dynamic meshes must not collapse all worlds onto env0's mesh."""
+  from contextlib import nullcontext
+
+  from mjlab.envs import ManagerBasedRlEnv, ManagerBasedRlEnvCfg
+  from mjlab.scene import SceneCfg
+  from mjlab.terrains import TerrainEntityCfg
+  from mjlab.viewer.viser.scene import MjlabViserScene, _PerWorldMeshGroup
+
+  class _Handle:
+    def __init__(self, **kwargs):
+      self.visible = kwargs.get("visible", True)
+      self.batched_positions = kwargs.get("batched_positions", np.zeros((0, 3)))
+      self.batched_wxyzs = kwargs.get("batched_wxyzs", np.zeros((0, 4)))
+      self.batched_scales = kwargs.get("batched_scales")
+      self.batched_colors = kwargs.get("batched_colors")
+      self.batched_opacities = kwargs.get("batched_opacities")
+      self.position = kwargs.get("position", np.zeros(3))
+      self.wxyz = kwargs.get("wxyz", np.array([1.0, 0.0, 0.0, 0.0]))
+
+    def remove(self) -> None:
+      pass
+
+  class _Scene:
+    def __init__(self):
+      self.batched: list[tuple[tuple, dict, _Handle]] = []
+
+    def configure_environment_map(self, **_kwargs) -> None:
+      pass
+
+    def add_frame(self, *_args, **kwargs) -> _Handle:
+      return _Handle(**kwargs)
+
+    def add_grid(self, *_args, **kwargs) -> _Handle:
+      return _Handle(**kwargs)
+
+    def add_mesh_trimesh(self, *_args, **kwargs) -> _Handle:
+      return _Handle(**kwargs)
+
+    def add_batched_meshes_trimesh(self, *args, **kwargs) -> _Handle:
+      handle = _Handle(**kwargs)
+      self.batched.append((args, kwargs, handle))
+      return handle
+
+    def add_batched_meshes_simple(self, *args, **kwargs) -> _Handle:
+      handle = _Handle(**kwargs)
+      self.batched.append((args, kwargs, handle))
+      return handle
+
+  class _Server:
+    def __init__(self):
+      self.scene = _Scene()
+
+    def atomic(self):
+      return nullcontext()
+
+    def flush(self) -> None:
+      pass
+
+  env_cfg = ManagerBasedRlEnvCfg(
+    decimation=1,
+    scene=SceneCfg(
+      terrain=TerrainEntityCfg(terrain_type="plane"),
+      num_envs=4,
+      env_spacing=1.0,
+      entities={
+        "object": VariantEntityCfg(
+          variants={
+            "sphere": _simple_sphere_spec,
+            "cone": _simple_cone_spec,
+          },
+          init_state=EntityCfg.InitialStateCfg(pos=(0.0, 0.0, 0.2)),
+        )
+      },
+    ),
+  )
+
+  env = ManagerBasedRlEnv(cfg=env_cfg, device="cpu")
+  try:
+    env.sim.expand_model_fields(("geom_rgba",))
+    env.sim.model.geom_rgba[:, :, :3] = torch.linspace(
+      0.2,
+      0.9,
+      env.num_envs,
+      device=env.device,
+    )[:, None, None]
+    server = _Server()
+    scene = MjlabViserScene(
+      cast(Any, server),
+      env.sim.mj_model,
+      env.num_envs,
+      sim_model=env.sim.model,
+      expanded_fields=env.sim.expanded_fields,
+    )
+    groups = [mg for mg in scene._mesh_groups if isinstance(mg, _PerWorldMeshGroup)]
+
+    assert groups
+    assert sum(len(mg.env_ids) for mg in groups) >= env.num_envs
+
+    body_xpos = env.sim.data.xpos.cpu().numpy()
+    body_xmat = env.sim.data.xmat.cpu().numpy()
+    mocap_pos = (
+      env.sim.data.mocap_pos.cpu().numpy() if env.sim.mj_model.nmocap > 0 else None
+    )
+    mocap_quat = (
+      env.sim.data.mocap_quat.cpu().numpy() if env.sim.mj_model.nmocap > 0 else None
+    )
+    scene.show_only_selected = True
+    scene.update_from_arrays(body_xpos, body_xmat, mocap_pos, mocap_quat, env_idx=0)
+    scene.update_from_arrays(body_xpos, body_xmat, mocap_pos, mocap_quat, env_idx=1)
+
+    assert any(mg.handle.visible for mg in groups)
+
+    handle_count = len(server.scene.batched)
+    env.sim.model.geom_rgba[:, :, :3] = torch.linspace(
+      0.9,
+      0.2,
+      env.num_envs,
+      device=env.device,
+    )[:, None, None]
+    scene.update_from_arrays(body_xpos, body_xmat, mocap_pos, mocap_quat, env_idx=0)
+    assert len(server.scene.batched) > handle_count
+  finally:
+    env.close()
+
+
+def test_viser_convex_hulls_are_per_variant():
+  """Convex-hull handles must differ across variants, not all show env0's hull."""
+  from contextlib import nullcontext
+
+  from mjlab.envs import ManagerBasedRlEnv, ManagerBasedRlEnvCfg
+  from mjlab.scene import SceneCfg
+  from mjlab.terrains import TerrainEntityCfg
+  from mjlab.viewer.viser.scene import MjlabViserScene, _PerWorldHullGroup
+
+  class _Handle:
+    def __init__(self, **kwargs):
+      self.visible = kwargs.get("visible", True)
+      self.batched_positions = kwargs.get("batched_positions", np.zeros((0, 3)))
+      self.batched_wxyzs = kwargs.get("batched_wxyzs", np.zeros((0, 4)))
+      self.batched_scales = kwargs.get("batched_scales")
+      self.batched_colors = kwargs.get("batched_colors")
+      self.batched_opacities = kwargs.get("batched_opacities")
+      self.position = kwargs.get("position", np.zeros(3))
+      self.wxyz = kwargs.get("wxyz", np.array([1.0, 0.0, 0.0, 0.0]))
+      self.vertices = kwargs.get("vertices")
+      self.faces = kwargs.get("faces")
+
+    def remove(self) -> None:
+      pass
+
+  class _Scene:
+    def __init__(self):
+      self.batched: list[tuple[tuple, dict, _Handle]] = []
+
+    def configure_environment_map(self, **_kwargs) -> None:
+      pass
+
+    def add_frame(self, *_args, **kwargs) -> _Handle:
+      return _Handle(**kwargs)
+
+    def add_grid(self, *_args, **kwargs) -> _Handle:
+      return _Handle(**kwargs)
+
+    def add_mesh_trimesh(self, *_args, **kwargs) -> _Handle:
+      return _Handle(**kwargs)
+
+    def add_batched_meshes_trimesh(self, *args, **kwargs) -> _Handle:
+      handle = _Handle(**kwargs)
+      self.batched.append((args, kwargs, handle))
+      return handle
+
+    def add_batched_meshes_simple(self, path, vertices, faces, **kwargs) -> _Handle:
+      # Capture the mesh identity so the test can compare hull shapes.
+      kwargs = dict(kwargs)
+      kwargs["vertices"] = np.asarray(vertices)
+      kwargs["faces"] = np.asarray(faces)
+      handle = _Handle(**kwargs)
+      self.batched.append(((path,), kwargs, handle))
+      return handle
+
+  class _Server:
+    def __init__(self):
+      self.scene = _Scene()
+
+    def atomic(self):
+      return nullcontext()
+
+    def flush(self) -> None:
+      pass
+
+  # Sphere and cone produce visibly different convex hulls.
+  env_cfg = ManagerBasedRlEnvCfg(
+    decimation=1,
+    scene=SceneCfg(
+      terrain=TerrainEntityCfg(terrain_type="plane"),
+      num_envs=4,
+      env_spacing=1.0,
+      entities={
+        "object": VariantEntityCfg(
+          variants={
+            "sphere": _simple_sphere_spec,
+            "cone": _simple_cone_spec,
+          },
+          init_state=EntityCfg.InitialStateCfg(pos=(0.0, 0.0, 0.2)),
+        )
+      },
+    ),
+  )
+
+  env = ManagerBasedRlEnv(cfg=env_cfg, device="cpu")
+  try:
+    server = _Server()
+    scene = MjlabViserScene(
+      cast(Any, server),
+      env.sim.mj_model,
+      env.num_envs,
+      sim_model=env.sim.model,
+      expanded_fields=env.sim.expanded_fields,
+    )
+    groups: list[_PerWorldHullGroup] = list(scene._hull_per_world_groups)
+    # Two distinct variants -> at least two hull handles on the same body.
+    assert len(groups) >= 2, f"expected >=2 hull variants, got {len(groups)}"
+    all_envs = np.concatenate([g.env_ids for g in groups])
+    assert sorted(all_envs.tolist()) == list(range(env.num_envs))
+    # Hulls must be shape-distinct, not all copies of env0's hull.
+    shapes = {(g.handle.vertices.shape, g.handle.faces.shape) for g in groups}
+    assert len(shapes) >= 2, (
+      f"hull variants collapsed to one shape: {shapes} "
+      "(all envs would share env0's hull)"
+    )
+
+    body_xpos = env.sim.data.xpos.cpu().numpy()
+    body_xmat = env.sim.data.xmat.cpu().numpy()
+    scene.show_convex_hull = True
+    scene.show_only_selected = True
+    for target_env in range(env.num_envs):
+      scene.update_from_arrays(body_xpos, body_xmat, env_idx=target_env)
+      visible_groups = [g for g in groups if g.handle.visible]
+      assert len(visible_groups) == 1
+      assert target_env in visible_groups[0].env_ids
+      assert visible_groups[0].handle.batched_positions.shape[0] == 1
+
+    scene.show_only_selected = False
+    scene.update_from_arrays(body_xpos, body_xmat, env_idx=0)
+    assert all(g.handle.visible for g in groups)
+  finally:
+    env.close()
+
+
+# DR consistency on variant scenes.
+
+
+def _explicit_mass_variant(
+  mesh_name: str,
+  mass: float,
+  *,
+  cone: bool = False,
+) -> mujoco.MjSpec:
+  """Build a single-geom freejoint variant with an explicit body mass."""
+  spec = mujoco.MjSpec()
+  mesh = spec.add_mesh()
+  mesh.name = mesh_name
+  if cone:
+    mesh.make_cone(nedge=8, radius=0.05)
+  else:
+    mesh.make_sphere(subdivision=1)
+  body = spec.worldbody.add_body(name="prop")
+  body.add_freejoint()
+  body.explicitinertial = True
+  body.mass = mass
+  body.ipos[:] = (0.0, 0.0, 0.0)
+  body.inertia[:] = (1e-4, 1e-4, 1e-4)
+  body.iquat[:] = (1.0, 0.0, 0.0, 0.0)
+  body.add_geom(
+    name="visual",
+    type=mujoco.mjtGeom.mjGEOM_MESH,
+    meshname=mesh_name,
+    contype=0,
+    conaffinity=0,
+    mass=0.0,
+  )
+  return spec
+
+
+def test_dr_body_mass_scale_preserves_variant_baseline():
+  """``dr.body_mass`` scale must use each variant's own baseline.
+
+  This is the load-bearing claim of ``_per_world_default_fields``: scaling
+  body_mass on a variant scene by a per-env factor must produce
+  ``variant_default[env] * scale[env]``, not ``template_default * scale[env]``.
+  """
+  from mjlab.envs import ManagerBasedRlEnv, ManagerBasedRlEnvCfg
+  from mjlab.envs.mdp import dr
+  from mjlab.managers.event_manager import EventTermCfg
+  from mjlab.managers.scene_entity_config import SceneEntityCfg
+  from mjlab.scene import SceneCfg
+  from mjlab.terrains import TerrainEntityCfg
+
+  light_mass = 0.1
+  heavy_mass = 1.0
+  scale = 2.0
+
+  object_cfg = VariantEntityCfg(
+    variants={
+      "light": lambda: _explicit_mass_variant("light", light_mass),
+      "heavy": lambda: _explicit_mass_variant("heavy", heavy_mass, cone=True),
+    },
+    init_state=EntityCfg.InitialStateCfg(pos=(0.0, 0.0, 0.2)),
+  )
+  env_cfg = ManagerBasedRlEnvCfg(
+    decimation=1,
+    scene=SceneCfg(
+      terrain=TerrainEntityCfg(terrain_type="plane"),
+      num_envs=4,
+      env_spacing=1.0,
+      entities={"object": object_cfg},
+    ),
+    events={
+      "scale_mass": EventTermCfg(
+        func=dr.body_mass,
+        mode="startup",
+        params={
+          "asset_cfg": SceneEntityCfg("object", body_names=("prop",)),
+          "operation": "scale",
+          "ranges": (scale, scale),  # deterministic factor
+        },
+      ),
+    },
+  )
+
+  with pytest.warns(UserWarning, match="dr.body_mass only randomizes mass"):
+    env = ManagerBasedRlEnv(cfg=env_cfg, device="cpu")
+  try:
+    obj_body = int(env.scene["object"].indexing.root_body_id)
+    w2v = env.sim.world_to_variant["object"]
+    actual = env.sim.model.body_mass[:, obj_body].cpu()
+
+    variant_baseline = torch.tensor([light_mass, heavy_mass], dtype=actual.dtype)
+    expected = variant_baseline[w2v.cpu()] * scale
+    torch.testing.assert_close(actual, expected, atol=1e-5, rtol=1e-5)
+
+    # Sanity: at least one env per variant, otherwise the test is vacuous.
+    assert (w2v == 0).any() and (w2v == 1).any()
+  finally:
+    env.close()
+
+
+# Full env lifecycle.
+
+
+def test_env_step_with_variants():
+  """Build a full ManagerBasedRlEnv with variants; step without crashing."""
+  from mjlab.envs import ManagerBasedRlEnv, ManagerBasedRlEnvCfg
+  from mjlab.envs.mdp.events import reset_root_state_uniform
+  from mjlab.managers.event_manager import EventTermCfg
+  from mjlab.managers.scene_entity_config import SceneEntityCfg
+  from mjlab.scene import SceneCfg
+  from mjlab.terrains import TerrainEntityCfg
+
+  object_cfg = VariantEntityCfg(
+    variants={
+      "sphere": _simple_sphere_spec,
+      "cone": _simple_cone_spec,
+    },
+    init_state=EntityCfg.InitialStateCfg(pos=(0.0, 0.0, 0.2)),
+  )
+
+  env_cfg = ManagerBasedRlEnvCfg(
+    decimation=2,
+    scene=SceneCfg(
+      terrain=TerrainEntityCfg(terrain_type="plane"),
+      num_envs=4,
+      env_spacing=1.0,
+      entities={"object": object_cfg},
+    ),
+    events={
+      "reset": EventTermCfg(
+        func=reset_root_state_uniform,
+        mode="reset",
+        params={
+          "pose_range": {},
+          "velocity_range": {},
+          "asset_cfg": SceneEntityCfg("object"),
+        },
+      ),
+    },
+  )
+
+  env = ManagerBasedRlEnv(cfg=env_cfg, device="cpu")
+  obs, _ = env.reset()
+  actions = torch.zeros(env.num_envs, 0)
+  for _ in range(10):
+    obs, rew, term, trunc, info = env.step(actions)
+  # No NaN in positions.
+  qpos = env.sim.data.qpos[:].cpu().numpy()
+  assert np.all(np.isfinite(qpos))
+  env.close()
+
+
+# Viewer: sameframe shortcut fix.
+
+
+def _viewer_regression_sphere_spec() -> mujoco.MjSpec:
+  spec = mujoco.MjSpec()
+  m = spec.add_mesh()
+  m.name = "sphere"
+  m.make_sphere(subdivision=3)
+  m.scale[:] = (0.05, 0.05, 0.05)
+  body = spec.worldbody.add_body()
+  body.name = "prop"
+  body.add_freejoint()
+  g = body.add_geom()
+  g.name = "visual"
+  g.type = mujoco.mjtGeom.mjGEOM_MESH
+  g.meshname = "sphere"
+  return spec
+
+
+def _viewer_regression_cone_spec() -> mujoco.MjSpec:
+  spec = mujoco.MjSpec()
+  m = spec.add_mesh()
+  m.name = "cone"
+  m.make_cone(nedge=16, radius=0.04)
+  m.scale[:] = (0.05, 0.05, 0.05)
+  body = spec.worldbody.add_body()
+  body.name = "prop"
+  body.add_freejoint()
+  g = body.add_geom()
+  g.name = "visual"
+  g.type = mujoco.mjtGeom.mjGEOM_MESH
+  g.meshname = "cone"
+  return spec
+
+
+def test_sameframe_fix_makes_host_forward_match_variant():
+  """Clearing sameframe shortcuts aligns host mj_forward with variant."""
+  base_model = _viewer_regression_sphere_spec().compile()
+  cone_model = _viewer_regression_cone_spec().compile()
+
+  # Sync cone's kinematic fields onto sphere's model (like viewer does).
+  for field in (
+    "geom_size",
+    "geom_pos",
+    "geom_quat",
+    "body_mass",
+    "body_inertia",
+    "body_ipos",
+    "body_iquat",
+  ):
+    getattr(base_model, field)[:] = getattr(cone_model, field)
+
+  base_data = mujoco.MjData(base_model)
+  base_data.qpos[:] = cone_model.qpos0
+  base_data.qpos[2] = 0.05
+  mujoco.mj_forward(base_model, base_data)
+
+  cone_data = mujoco.MjData(cone_model)
+  cone_data.qpos[:] = cone_model.qpos0
+  cone_data.qpos[2] = 0.05
+  mujoco.mj_forward(cone_model, cone_data)
+
+  # Before fix: positions differ due to stale sameframe flags.
+  assert not np.allclose(base_data.geom_xpos, cone_data.geom_xpos)
+
+  # After fix: clearing sameframe makes them match.
+  disable_model_sameframe_shortcuts(base_model)
+  mujoco.mj_forward(base_model, base_data)
+  np.testing.assert_allclose(base_data.geom_xpos, cone_data.geom_xpos, atol=1e-6)
+
+
+def test_sync_model_fields_copies_only_requested_env_fields():
+  """Viewer model sync copies explicit fields and leaves others unchanged."""
+  model = _simple_sphere_spec().compile()
+
+  class _SimModel:
+    geom_rgba = torch.tensor(
+      [
+        [[0.1, 0.2, 0.3, 0.4]],
+        [[0.5, 0.6, 0.7, 0.8]],
+      ],
+      dtype=torch.float32,
+    )
+    geom_pos = torch.tensor(
+      [
+        [[1.0, 2.0, 3.0]],
+        [[4.0, 5.0, 6.0]],
+      ],
+      dtype=torch.float32,
+    )
+
+  original_geom_pos = model.geom_pos.copy()
+
+  sync_model_fields(model, _SimModel(), {"geom_rgba"}, env_idx=1)
+
+  np.testing.assert_allclose(model.geom_rgba, [[0.5, 0.6, 0.7, 0.8]])
+  np.testing.assert_allclose(model.geom_pos, original_geom_pos)
diff --git a/tests/test_velocity_command.py b/tests/test_velocity_command.py
new file mode 100644
index 0000000..1873d83
--- /dev/null
+++ b/tests/test_velocity_command.py
@@ -0,0 +1,120 @@
+"""Tests for the velocity command's initial-velocity injection.
+
+The init_velocity_prob path runs inside the reset pipeline, after reset
+events wrote the new pose to qpos but before sim.forward(), so it must not
+read (or write back) derived kinematics.
+"""
+
+from types import SimpleNamespace
+from typing import TYPE_CHECKING, cast
+
+import pytest
+import torch
+from conftest import get_test_device, load_fixture_xml, make_scene_and_sim
+
+from mjlab.tasks.velocity.mdp.velocity_command import UniformVelocityCommandCfg
+
+if TYPE_CHECKING:
+  from mjlab.envs import ManagerBasedRlEnv
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+def test_init_velocity_preserves_fresh_reset_pose(device):
+  scene, sim = make_scene_and_sim(
+    device, load_fixture_xml("floating_base_articulated"), sensors=(), num_envs=2
+  )
+  env = cast(
+    "ManagerBasedRlEnv",
+    SimpleNamespace(scene=scene, sim=sim, num_envs=2, device=device),
+  )
+  cfg = UniformVelocityCommandCfg(
+    entity_name="robot",
+    resampling_time_range=(1e9, 1e9),
+    init_velocity_prob=1.0,
+    rel_heading_envs=0.0,
+    ranges=UniformVelocityCommandCfg.Ranges(
+      lin_vel_x=(0.5, 0.5), lin_vel_y=(0.2, 0.2), ang_vel_z=(0.0, 0.0)
+    ),
+  )
+  term = cfg.build(env)
+  robot = scene["robot"]
+  env_ids = torch.arange(2, device=device)
+
+  # Derived kinematics now hold the spawn pose (the "previous episode" state).
+  sim.forward()
+
+  # Emulate a reset event: write a fresh pose to qpos, no forward yet.
+  pose = torch.tensor(
+    [
+      [1.0, 2.0, 1.5, 1.0, 0.0, 0.0, 0.0],
+      [3.0, -1.0, 1.5, 1.0, 0.0, 0.0, 0.0],
+    ],
+    device=device,
+  )
+  robot.write_root_link_pose_to_sim(pose, env_ids=env_ids)
+
+  term.reset(env_ids=env_ids)
+  sim.forward()
+
+  # The fresh reset pose survives. Before the fix, the init-velocity path
+  # wrote the stale pre-reset pose back into the sim.
+  assert torch.allclose(robot.data.root_link_pos_w, pose[:, :3], atol=1e-6)
+
+  # Planar velocity matches the sampled command (identity orientation, so
+  # body frame equals world frame).
+  assert torch.allclose(
+    robot.data.root_link_lin_vel_b[:, :2],
+    term.vel_command_b[:, :2],
+    atol=1e-5,
+  )
+
+
+def test_mid_episode_resample_does_not_write_velocity(device):
+  """Init velocity applies on reset only; a timer-expiry resample runs after
+  step()'s forward and must not write sim state."""
+  scene, sim = make_scene_and_sim(
+    device, load_fixture_xml("floating_base_articulated"), sensors=(), num_envs=2
+  )
+  env = cast(
+    "ManagerBasedRlEnv",
+    SimpleNamespace(scene=scene, sim=sim, num_envs=2, device=device, step_dt=0.02),
+  )
+  cfg = UniformVelocityCommandCfg(
+    entity_name="robot",
+    resampling_time_range=(0.001, 0.001),  # Expires on the first compute.
+    init_velocity_prob=1.0,
+    rel_heading_envs=0.0,
+    ranges=UniformVelocityCommandCfg.Ranges(
+      lin_vel_x=(0.7, 0.7), lin_vel_y=(0.3, 0.3), ang_vel_z=(0.0, 0.0)
+    ),
+  )
+  term = cfg.build(env)
+  robot = scene["robot"]
+  env_ids = torch.arange(2, device=device)
+
+  term.reset(env_ids=env_ids)
+  sim.forward()
+
+  # Mid-episode the robot has decelerated to rest.
+  robot.write_root_link_velocity_to_sim(
+    torch.zeros(2, 6, device=device), env_ids=env_ids
+  )
+  sim.forward()
+
+  # Step's command compute: the 1 ms timer expires and resamples.
+  counter = term.command_counter.clone()
+  term.compute(dt=1.0)
+  assert (term.command_counter > counter).all()
+
+  # Only the command changed; sim velocity is untouched.
+  qvel_lin = sim.data.qvel[:, robot.indexing.free_joint_v_adr[:3]]
+  assert torch.allclose(qvel_lin, torch.zeros_like(qvel_lin), atol=1e-6)
+  assert torch.allclose(
+    robot.data.root_link_lin_vel_b,
+    torch.zeros_like(robot.data.root_link_lin_vel_b),
+    atol=1e-6,
+  )
diff --git a/tests/test_velocity_rewards.py b/tests/test_velocity_rewards.py
new file mode 100644
index 0000000..579bc08
--- /dev/null
+++ b/tests/test_velocity_rewards.py
@@ -0,0 +1,190 @@
+"""Tests for velocity task reward functions."""
+
+from __future__ import annotations
+
+import math
+from unittest.mock import MagicMock, PropertyMock
+
+import torch
+
+from mjlab.managers.reward_manager import RewardTermCfg
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.sensor import RayCastData, RayCastSensor
+from mjlab.tasks.velocity.mdp.rewards import upright
+from mjlab.utils.lab_api.math import quat_from_euler_xyz
+
+
+def _identity_quat(B: int) -> torch.Tensor:
+  """(w, x, y, z) = (1, 0, 0, 0)."""
+  q = torch.zeros(B, 4)
+  q[:, 0] = 1.0
+  return q
+
+
+def _quat_from_roll(roll_rad: float, B: int = 1) -> torch.Tensor:
+  roll = torch.full((B,), roll_rad)
+  zero = torch.zeros(B)
+  return quat_from_euler_xyz(roll, zero, zero)
+
+
+def _quat_from_pitch(pitch_rad: float, B: int = 1) -> torch.Tensor:
+  pitch = torch.full((B,), pitch_rad)
+  zero = torch.zeros(B)
+  return quat_from_euler_xyz(zero, pitch, zero)
+
+
+def _make_env_and_reward(
+  terrain_sensor_names: tuple[str, ...] | None = None,
+  body_quat_w: torch.Tensor | None = None,
+  terrain_hit_z: float = 0.0,
+  terrain_slope_x: float = 0.0,
+):
+  """Build mocked env + upright reward instance.
+
+  Args:
+    terrain_sensor_names: If set, enables terrain-aware mode.
+    body_quat_w: [B, 4] root orientation. Defaults to identity.
+    terrain_hit_z: Z value for flat terrain hits.
+    terrain_slope_x: Slope in X (z = terrain_slope_x * x).
+  """
+  B = 1 if body_quat_w is None else body_quat_w.shape[0]
+  if body_quat_w is None:
+    body_quat_w = _identity_quat(B)
+
+  # Mock asset data. Use explicit asset_cfg with no body_names so
+  # body_ids stays None and the reward uses root_link_quat_w.
+  asset = MagicMock()
+  asset.data.root_link_quat_w = body_quat_w
+  asset.data.root_link_pos_w = torch.zeros(B, 3)
+  asset.data.gravity_vec_w = torch.tensor([0.0, 0.0, -1.0]).expand(B, 3)
+  asset_cfg = SceneEntityCfg("robot", body_names=None, body_ids=[])
+
+  # Mock terrain sensor if needed.
+  sensors: dict = {"robot": asset}
+  if terrain_sensor_names is not None:
+    N = 100
+    torch.manual_seed(0)
+    hit_pos = torch.zeros(B, N, 3)
+    hit_pos[:, :, 0] = torch.randn(B, N)
+    hit_pos[:, :, 1] = torch.randn(B, N)
+    hit_pos[:, :, 2] = terrain_hit_z + terrain_slope_x * hit_pos[:, :, 0]
+
+    raycast_sensor = MagicMock(spec=RayCastSensor)
+    raycast_data = RayCastData(
+      distances=torch.ones(B, N),
+      normals_w=torch.zeros(B, N, 3),
+      hit_pos_w=hit_pos,
+      pos_w=torch.zeros(B, 3),
+      quat_w=torch.zeros(B, 4),
+      frame_pos_w=torch.zeros(B, 1, 3),
+      frame_quat_w=torch.zeros(B, 1, 4),
+    )
+    type(raycast_sensor).data = PropertyMock(return_value=raycast_data)
+    for name in terrain_sensor_names:
+      sensors[name] = raycast_sensor
+
+  env = MagicMock()
+  env.scene.__getitem__ = MagicMock(side_effect=lambda n: sensors[n])
+
+  params: dict = {"std": 1.0, "asset_cfg": asset_cfg}
+  if terrain_sensor_names is not None:
+    params["terrain_sensor_names"] = terrain_sensor_names
+  cfg = MagicMock(spec=RewardTermCfg)
+  cfg.params = params
+
+  reward_fn = upright(cfg, env)
+  return env, reward_fn, params
+
+
+def test_world_up_identity_gives_max_reward():
+  """Perfectly upright robot on flat ground → reward ≈ 1."""
+  env, reward, params = _make_env_and_reward()
+  r = reward(env, std=params["std"], asset_cfg=params["asset_cfg"])
+  assert r.shape == (1,)
+  assert r.item() > 0.99
+
+
+def test_world_up_tilted_gives_lower_reward():
+  """30° roll → reward significantly below 1."""
+  quat = _quat_from_roll(math.radians(30))
+  env, reward, params = _make_env_and_reward(body_quat_w=quat)
+  r = reward(env, std=params["std"], asset_cfg=params["asset_cfg"])
+  assert r.item() < 0.8
+
+
+def test_terrain_aware_aligned_with_slope():
+  """Robot pitched to match a slope → terrain-aware reward ≈ 1."""
+  slope = 0.5  # z = 0.5 * x
+  tilt = math.atan(slope)  # Pitch to match slope in XZ plane.
+  quat = _quat_from_pitch(-tilt)
+  env, reward, params = _make_env_and_reward(
+    terrain_sensor_names=("terrain_scan",),
+    body_quat_w=quat,
+    terrain_slope_x=slope,
+  )
+  r = reward(
+    env,
+    std=params["std"],
+    asset_cfg=params["asset_cfg"],
+    terrain_sensor_names=params["terrain_sensor_names"],
+  )
+  # Should be close to 1 since robot matches terrain.
+  assert r.item() > 0.9
+
+
+def test_terrain_aware_upright_on_slope_penalized():
+  """Robot staying vertical on a slope → terrain-aware reward < 1."""
+  slope = 0.5
+  quat = _identity_quat(1)  # Robot is world-vertical, not matching slope.
+  env, reward, params = _make_env_and_reward(
+    terrain_sensor_names=("terrain_scan",),
+    body_quat_w=quat,
+    terrain_slope_x=slope,
+  )
+  r = reward(
+    env,
+    std=params["std"],
+    asset_cfg=params["asset_cfg"],
+    terrain_sensor_names=params["terrain_sensor_names"],
+  )
+  # Should be penalized since robot doesn't match terrain.
+  assert r.item() < 0.95
+
+
+def test_terrain_aware_flat_ground_matches_world_up():
+  """On flat terrain, terrain-aware and world-up should give same reward."""
+  quat = _quat_from_roll(math.radians(15))
+  env_t, reward_t, params_t = _make_env_and_reward(
+    terrain_sensor_names=("terrain_scan",),
+    body_quat_w=quat,
+  )
+  env_w, reward_w, params_w = _make_env_and_reward(body_quat_w=quat)
+
+  r_terrain = reward_t(
+    env_t,
+    std=params_t["std"],
+    asset_cfg=params_t["asset_cfg"],
+    terrain_sensor_names=params_t["terrain_sensor_names"],
+  )
+  r_world = reward_w(env_w, std=params_w["std"], asset_cfg=params_w["asset_cfg"])
+
+  torch.testing.assert_close(r_terrain, r_world, atol=0.02, rtol=0.02)
+
+
+def test_batch_consistency():
+  """Multiple envs with different orientations get independent rewards."""
+  B = 4
+  quats = torch.zeros(B, 4)
+  quats[:, 0] = 1.0  # All identity.
+  # Tilt env 2 by 45°.
+  quats[2] = _quat_from_roll(math.radians(45))[0]
+
+  env, reward, params = _make_env_and_reward(body_quat_w=quats)
+  r = reward(env, std=params["std"], asset_cfg=params["asset_cfg"])
+
+  assert r.shape == (B,)
+  # Env 0, 1, 3 should be ~1, env 2 should be lower.
+  assert r[0].item() > 0.99
+  assert r[1].item() > 0.99
+  assert r[2].item() < 0.7
+  assert r[3].item() > 0.99
diff --git a/tests/test_velocity_task.py b/tests/test_velocity_task.py
new file mode 100644
index 0000000..b5fca69
--- /dev/null
+++ b/tests/test_velocity_task.py
@@ -0,0 +1,199 @@
+"""Tests specific to velocity tasks."""
+
+import pytest
+
+from mjlab.asset_zoo.robots import G1_ACTION_SCALE, GO1_ACTION_SCALE
+from mjlab.envs.mdp.actions import JointPositionActionCfg
+from mjlab.tasks.registry import list_tasks, load_env_cfg
+from mjlab.tasks.velocity.mdp import UniformVelocityCommandCfg
+
+
+@pytest.fixture(scope="module")
+def velocity_task_ids() -> list[str]:
+  """Get all velocity task IDs."""
+  return [t for t in list_tasks() if "Velocity" in t]
+
+
+@pytest.fixture(scope="module")
+def g1_velocity_task_ids(velocity_task_ids: list[str]) -> list[str]:
+  """Get all G1 velocity task IDs."""
+  return [t for t in velocity_task_ids if "G1" in t]
+
+
+@pytest.fixture(scope="module")
+def go1_velocity_task_ids(velocity_task_ids: list[str]) -> list[str]:
+  """Get all Go1 velocity task IDs."""
+  return [t for t in velocity_task_ids if "Go1" in t]
+
+
+@pytest.fixture(scope="module")
+def rough_velocity_task_ids(velocity_task_ids: list[str]) -> list[str]:
+  """Get all rough terrain velocity task IDs."""
+  return [t for t in velocity_task_ids if "Rough" in t]
+
+
+@pytest.fixture(scope="module")
+def flat_velocity_task_ids(velocity_task_ids: list[str]) -> list[str]:
+  """Get all flat terrain velocity task IDs."""
+  return [t for t in velocity_task_ids if "Flat" in t]
+
+
+def test_velocity_tasks_have_twist_command(velocity_task_ids: list[str]) -> None:
+  """All velocity tasks should have a velocity command."""
+  for task_id in velocity_task_ids:
+    cfg = load_env_cfg(task_id)
+
+    assert "twist" in cfg.commands, f"Task {task_id} missing 'twist' command"
+
+    twist_cmd = cfg.commands["twist"]
+    assert isinstance(twist_cmd, UniformVelocityCommandCfg), (
+      f"Task {task_id} twist command is not UniformVelocityCommandCfg"
+    )
+
+
+def test_g1_velocity_has_required_sensors(g1_velocity_task_ids: list[str]) -> None:
+  """G1 velocity tasks should have feet/ground and self collision sensors."""
+  for task_id in g1_velocity_task_ids:
+    cfg = load_env_cfg(task_id)
+
+    assert cfg.scene.sensors is not None, f"Task {task_id} has no sensors"
+
+    sensor_names = {s.name for s in cfg.scene.sensors}
+    assert "feet_ground_contact" in sensor_names, (
+      f"Task {task_id} missing feet_ground_contact sensor"
+    )
+    assert "self_collision" in sensor_names, (
+      f"Task {task_id} missing self_collision sensor"
+    )
+
+
+def test_go1_velocity_has_required_sensors(go1_velocity_task_ids: list[str]) -> None:
+  """Go1 velocity tasks should have feet/ground and collision sensors."""
+  for task_id in go1_velocity_task_ids:
+    cfg = load_env_cfg(task_id)
+
+    assert cfg.scene.sensors is not None, f"Task {task_id} has no sensors"
+
+    sensor_names = {s.name for s in cfg.scene.sensors}
+    assert "feet_ground_contact" in sensor_names, (
+      f"Task {task_id} missing feet_ground_contact sensor"
+    )
+    if "Rough" in task_id:
+      for name in (
+        "self_collision",
+        "thigh_ground_touch",
+        "shank_ground_touch",
+        "trunk_ground_touch",
+      ):
+        assert name in sensor_names, f"Task {task_id} missing {name} sensor"
+
+
+def test_flat_velocity_tasks_have_plane_terrain(
+  flat_velocity_task_ids: list[str],
+) -> None:
+  """Flat velocity tasks should have terrain_type='plane' and no terrain_generator."""
+  for task_id in flat_velocity_task_ids:
+    cfg = load_env_cfg(task_id)
+
+    assert cfg.scene.terrain is not None, f"Task {task_id} has no terrain config"
+    assert cfg.scene.terrain.terrain_type == "plane", (
+      f"Task {task_id} terrain_type={cfg.scene.terrain.terrain_type}, expected 'plane'"
+    )
+    assert cfg.scene.terrain.terrain_generator is None, (
+      f"Task {task_id} has terrain_generator, expected None for flat terrain"
+    )
+
+
+def test_rough_velocity_tasks_have_generator_terrain(
+  rough_velocity_task_ids: list[str],
+) -> None:
+  """Rough velocity tasks should have generator terrain."""
+  for task_id in rough_velocity_task_ids:
+    cfg = load_env_cfg(task_id)
+
+    assert cfg.scene.terrain is not None, f"Task {task_id} has no terrain config"
+    assert cfg.scene.terrain.terrain_type == "generator", (
+      f"Task {task_id} terrain_type={cfg.scene.terrain.terrain_type}, "
+      "expected 'generator'"
+    )
+    assert cfg.scene.terrain.terrain_generator is not None, (
+      f"Task {task_id} has no terrain_generator, expected one for rough terrain"
+    )
+
+
+def test_rough_velocity_training_has_curriculum_enabled() -> None:
+  """Rough velocity training tasks should have terrain curriculum enabled."""
+  rough_training_tasks = [
+    "Mjlab-Velocity-Rough-Unitree-G1",
+    "Mjlab-Velocity-Rough-Unitree-Go1",
+  ]
+
+  for task_id in rough_training_tasks:
+    cfg = load_env_cfg(task_id)
+
+    assert cfg.scene.terrain is not None, f"Task {task_id} has no terrain config"
+    assert cfg.scene.terrain.terrain_generator is not None, (
+      f"Task {task_id} has no terrain_generator"
+    )
+    assert cfg.scene.terrain.terrain_generator.curriculum is True, (
+      f"Task {task_id} curriculum={cfg.scene.terrain.terrain_generator.curriculum}, "
+      "expected True"
+    )
+
+
+def test_rough_velocity_play_has_curriculum_disabled() -> None:
+  """Rough velocity play tasks should have terrain curriculum disabled."""
+  rough_training_tasks = [
+    "Mjlab-Velocity-Rough-Unitree-G1",
+    "Mjlab-Velocity-Rough-Unitree-Go1",
+  ]
+
+  for task_id in rough_training_tasks:
+    cfg = load_env_cfg(task_id, play=True)
+
+    assert cfg.scene.terrain is not None, (
+      f"Task {task_id} (play mode) has no terrain config"
+    )
+    assert cfg.scene.terrain.terrain_generator is not None, (
+      f"Task {task_id} (play mode) has no terrain_generator"
+    )
+    assert cfg.scene.terrain.terrain_generator.curriculum is False, (
+      f"Task {task_id} (play mode) curriculum={cfg.scene.terrain.terrain_generator.curriculum}, "
+      "expected False"
+    )
+
+
+def test_g1_velocity_has_correct_action_scale(g1_velocity_task_ids: list[str]) -> None:
+  """G1 velocity tasks should use G1_ACTION_SCALE."""
+  for task_id in g1_velocity_task_ids:
+    cfg = load_env_cfg(task_id)
+
+    assert "joint_pos" in cfg.actions, f"Task {task_id} missing 'joint_pos' action"
+
+    joint_pos_action = cfg.actions["joint_pos"]
+    assert isinstance(joint_pos_action, JointPositionActionCfg), (
+      f"Task {task_id} joint_pos action is not JointPositionActionCfg"
+    )
+
+    assert joint_pos_action.scale == G1_ACTION_SCALE, (
+      f"Task {task_id} action scale mismatch, expected G1_ACTION_SCALE"
+    )
+
+
+def test_go1_velocity_has_correct_action_scale(
+  go1_velocity_task_ids: list[str],
+) -> None:
+  """Go1 velocity tasks should use GO1_ACTION_SCALE."""
+  for task_id in go1_velocity_task_ids:
+    cfg = load_env_cfg(task_id)
+
+    assert "joint_pos" in cfg.actions, f"Task {task_id} missing 'joint_pos' action"
+
+    joint_pos_action = cfg.actions["joint_pos"]
+    assert isinstance(joint_pos_action, JointPositionActionCfg), (
+      f"Task {task_id} joint_pos action is not JointPositionActionCfg"
+    )
+
+    assert joint_pos_action.scale == GO1_ACTION_SCALE, (
+      f"Task {task_id} action scale mismatch, expected GO1_ACTION_SCALE"
+    )
diff --git a/tests/test_velocity_terrain_curriculum.py b/tests/test_velocity_terrain_curriculum.py
new file mode 100644
index 0000000..f24abe8
--- /dev/null
+++ b/tests/test_velocity_terrain_curriculum.py
@@ -0,0 +1,79 @@
+"""Tests for the velocity terrain-level curriculum."""
+
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import torch
+
+from mjlab.managers.scene_entity_config import SceneEntityCfg
+from mjlab.tasks.velocity.mdp.curriculums import terrain_levels_vel
+
+
+class _FakeTerrain:
+  """Minimal terrain stub implementing the real level-update arithmetic."""
+
+  def __init__(self, num_envs: int, size: float = 8.0):
+    self.terrain_levels = torch.zeros(num_envs, dtype=torch.long)
+    self.terrain_types = torch.zeros(num_envs, dtype=torch.long)
+    self.max_terrain_level = 10
+    # [num_rows, num_cols, 3]. One column, enough rows for promotion.
+    self.terrain_origins = torch.zeros(self.max_terrain_level, 1, 3)
+    self.env_origins = torch.zeros(num_envs, 3)
+    self.cfg = SimpleNamespace(
+      terrain_generator=SimpleNamespace(size=(size, size), sub_terrains={})
+    )
+
+  def update_env_origins(self, env_ids, move_up, move_down):
+    # Mirror TerrainEntity.update_env_origins exactly, including the cap-wrap
+    # branch and the env_origins write, so the fake can't pass vacuously.
+    self.terrain_levels[env_ids] += 1 * move_up - 1 * move_down
+    self.terrain_levels[env_ids] = torch.where(
+      self.terrain_levels[env_ids] >= self.max_terrain_level,
+      torch.randint_like(self.terrain_levels[env_ids], self.max_terrain_level),
+      torch.clip(self.terrain_levels[env_ids], 0),
+    )
+    self.env_origins[env_ids] = self.terrain_origins[
+      self.terrain_levels[env_ids], self.terrain_types[env_ids]
+    ]
+
+
+def _make_env(terrain: _FakeTerrain, common_step_counter: int, walked: float):
+  num_envs = terrain.terrain_levels.shape[0]
+  # Robot has "walked" `walked` meters in x from its origin.
+  asset = Mock()
+  asset.data.root_link_pos_w = torch.tensor([[walked, 0.0, 0.0]] * num_envs)
+
+  env = Mock()
+  env.common_step_counter = common_step_counter
+  env.max_episode_length_s = 20.0
+  env.scene.__getitem__ = Mock(return_value=asset)
+  env.scene.terrain = terrain
+  env.scene.env_origins = torch.zeros(num_envs, 3)
+  # Zero command so move_down stays inactive; isolates move_up behavior.
+  env.command_manager.get_command = Mock(return_value=torch.zeros(num_envs, 2))
+  return env
+
+
+def test_first_reset_does_not_promote_levels():
+  """On the initial reset the far spawn/origin gap must not bump levels."""
+  terrain = _FakeTerrain(num_envs=4, size=8.0)
+  # walked >> size/2 (=4.0), which would normally trigger move_up.
+  env = _make_env(terrain, common_step_counter=0, walked=100.0)
+
+  terrain_levels_vel(
+    env, torch.arange(4), command_name="twist", asset_cfg=SceneEntityCfg("robot")
+  )
+
+  assert torch.all(terrain.terrain_levels == 0)
+
+
+def test_subsequent_reset_promotes_on_long_walk():
+  """After stepping, a long walk still promotes the level as before."""
+  terrain = _FakeTerrain(num_envs=4, size=8.0)
+  env = _make_env(terrain, common_step_counter=1, walked=100.0)
+
+  terrain_levels_vel(
+    env, torch.arange(4), command_name="twist", asset_cfg=SceneEntityCfg("robot")
+  )
+
+  assert torch.all(terrain.terrain_levels == 1)
diff --git a/tests/test_video_recorder.py b/tests/test_video_recorder.py
new file mode 100644
index 0000000..1964cd7
--- /dev/null
+++ b/tests/test_video_recorder.py
@@ -0,0 +1,79 @@
+"""Tests for video recording with mediapy."""
+
+from pathlib import Path
+from unittest.mock import Mock
+
+import mediapy as media
+import numpy as np
+import torch
+
+
+def _make_mock_env(num_envs: int = 1):
+  """Create a mock environment that produces random RGB frames."""
+  env = Mock()
+  env.render_mode = "rgb_array"
+  env.metadata = {"render_fps": 30}
+  env.render.return_value = np.random.default_rng().integers(
+    0, 255, (num_envs, 64, 64, 3), dtype=np.uint8
+  )
+  env.step.return_value = (
+    torch.zeros(num_envs),  # obs
+    torch.zeros(num_envs),  # reward
+    torch.zeros(num_envs, dtype=torch.bool),  # terminated
+    torch.zeros(num_envs, dtype=torch.bool),  # truncated
+    {},  # info
+  )
+  env.close.return_value = None
+  env.unwrapped = env
+  return env
+
+
+def test_step_trigger_writes_video(tmp_path: Path):
+  """VideoRecorder writes a readable mp4 when the step trigger fires."""
+  from mjlab.utils.wrappers.video_recorder import VideoRecorder
+
+  env = _make_mock_env()
+  recorder = VideoRecorder(
+    env,
+    video_folder=tmp_path,
+    step_trigger=lambda step: step == 0,
+    video_length=5,
+    disable_logger=True,
+  )
+
+  action = torch.zeros(1)
+  for _ in range(6):
+    recorder.step(action)
+
+  recorder.close()
+
+  videos = list(tmp_path.glob("*.mp4"))
+  assert len(videos) == 1
+
+  # Verify the file is a valid video readable by mediapy.
+  frames = media.read_video(str(videos[0]))
+  assert len(frames) == 5
+  assert frames[0].shape == (64, 64, 3)
+
+
+def test_accepts_string_path(tmp_path: Path):
+  """VideoRecorder accepts a string path for video_folder."""
+  from mjlab.utils.wrappers.video_recorder import VideoRecorder
+
+  env = _make_mock_env()
+  folder = str(tmp_path / "vids")
+  recorder = VideoRecorder(
+    env,
+    video_folder=folder,
+    step_trigger=lambda step: step == 0,
+    video_length=3,
+    disable_logger=True,
+  )
+
+  action = torch.zeros(1)
+  for _ in range(4):
+    recorder.step(action)
+
+  recorder.close()
+
+  assert list(Path(folder).glob("*.mp4"))
diff --git a/tests/test_viewer_tick.py b/tests/test_viewer_tick.py
new file mode 100644
index 0000000..d49b1ed
--- /dev/null
+++ b/tests/test_viewer_tick.py
@@ -0,0 +1,269 @@
+"""Tests for the single-accumulator BaseViewer in base_alt.py."""
+
+from __future__ import annotations
+
+import time
+from unittest.mock import MagicMock
+
+from mjlab.viewer.base import BaseViewer
+
+
+class FakeViewer(BaseViewer):
+  """Minimal concrete viewer for testing."""
+
+  def __init__(self, step_dt: float = 0.01, frame_rate: float = 60.0):
+    env = MagicMock()
+    env.unwrapped.step_dt = step_dt
+    env.cfg.viewer = MagicMock()
+    super().__init__(env, MagicMock(return_value=MagicMock()), frame_rate=frame_rate)
+    self.sim_step_count = 0
+    self.render_count = 0
+    self._last_tick_time = time.perf_counter()
+
+  def setup(self) -> None: ...
+
+  def sync_env_to_viewer(self) -> None:
+    self.render_count += 1
+
+  def sync_viewer_to_env(self) -> None: ...
+  def close(self) -> None: ...
+  def is_running(self) -> bool:
+    return True
+
+  def _execute_step(self) -> bool:
+    self.sim_step_count += 1
+    self._step_count += 1
+    self._stats_steps += 1
+    return True
+
+  def inject_tick(self, dt: float) -> bool:
+    """Call tick() with a controlled dt."""
+    now = time.perf_counter()
+    self._last_tick_time = now - dt
+    return self.tick()
+
+
+# Physics stepping.
+
+
+def test_stepping():
+  """Physics steps match sim-time budget."""
+  v = FakeViewer(step_dt=0.01)
+  v.inject_tick(dt=0.01)
+  assert v.sim_step_count == 1
+
+  v.inject_tick(dt=0.03)
+  assert v.sim_step_count == 4
+
+  v.inject_tick(dt=0.0)
+  assert v.sim_step_count == 4
+
+
+def test_accumulator_carries():
+  """Fractional budget carries across ticks."""
+  v = FakeViewer(step_dt=0.01)
+  v.inject_tick(dt=0.01)
+  assert v.sim_step_count == 1
+
+  v.inject_tick(dt=0.015)
+  assert v.sim_step_count == 2  # 0.015 budget, 1 step, 0.005 carry
+
+  v.inject_tick(dt=0.015)
+  assert v.sim_step_count == 4  # 0.005+0.015=0.02, 2 steps
+
+
+def test_high_speed():
+  v = FakeViewer(step_dt=0.01, frame_rate=60.0)
+  v._speed_index = v.SPEED_MULTIPLIERS.index(8.0)
+  v._time_multiplier = 8.0
+  v.inject_tick(dt=1.0 / 60.0)
+  assert v.sim_step_count == 13
+
+
+def test_slow_speed():
+  v = FakeViewer(step_dt=0.01, frame_rate=60.0)
+  v._speed_index = 0
+  v._time_multiplier = 1 / 32
+  for _ in range(19):
+    v.inject_tick(dt=1.0 / 60.0)
+  assert v.sim_step_count == 0
+  for _ in range(3):
+    v.inject_tick(dt=1.0 / 60.0)
+  assert v.sim_step_count >= 1
+
+
+# Render timing.
+
+
+def test_render_at_frame_rate():
+  v = FakeViewer(step_dt=0.01, frame_rate=60.0)
+  assert v.inject_tick(dt=0.001) is True  # First tick renders.
+  assert v.inject_tick(dt=0.001) is False  # Too soon.
+  assert v.inject_tick(dt=1.0 / 60.0) is True  # Frame time elapsed.
+
+
+# Pause and resume.
+
+
+def test_pause_stops_physics():
+  v = FakeViewer(step_dt=0.01)
+  v.inject_tick(dt=0.02)
+  before = v.sim_step_count
+
+  v.pause()
+  v.inject_tick(dt=0.5)
+  assert v.sim_step_count == before
+
+
+def test_resume_no_burst():
+  v = FakeViewer(step_dt=0.01)
+  v.inject_tick(dt=0.03)
+  count_before = v.sim_step_count
+
+  v.pause()
+  v._last_error = "some error"
+
+  v.resume()
+  assert v._last_error is None
+  assert v._sim_budget == 0.0
+
+  v.inject_tick(dt=0.01)
+  assert v.sim_step_count - count_before == 1
+
+
+# Single step.
+
+
+def test_single_step_while_paused():
+  v = FakeViewer(step_dt=0.01)
+  v.pause()
+
+  v.request_single_step()
+  v.inject_tick(dt=0.0)
+
+  assert v.sim_step_count == 1
+  assert v._is_paused
+
+
+def test_single_step_ignored_when_running():
+  v = FakeViewer(step_dt=0.01)
+  v.inject_tick(dt=0.02)
+  before = v.sim_step_count
+
+  v.request_single_step()
+  v.inject_tick(dt=0.02)
+  assert v.sim_step_count > before
+
+
+# Error recovery.
+
+
+def test_error_pauses():
+  v = FakeViewer(step_dt=0.01)
+  v._execute_step = BaseViewer._execute_step.__get__(v, FakeViewer)  # type: ignore[attr-defined]
+  v.policy = MagicMock(side_effect=RuntimeError("test error"))
+
+  v.inject_tick(dt=0.02)
+
+  assert v._is_paused
+  assert v._last_error is not None
+  assert "test error" in v._last_error
+
+
+def test_reset_clears():
+  v = FakeViewer(step_dt=0.01)
+  v.inject_tick(dt=0.02)
+  v._last_error = "err"
+
+  v.reset_environment()
+  assert v._step_count == 0
+  assert v._sim_budget == 0.0
+  assert v._last_error is None
+
+
+def test_reset_calls_policy_reset():
+  """reset_environment() calls policy.reset() if available."""
+  v = FakeViewer(step_dt=0.01)
+  v.policy = MagicMock()
+  v.policy.reset = MagicMock()
+
+  v.reset_environment()
+  v.policy.reset.assert_called_once()
+
+
+def test_reset_without_policy_reset():
+  """reset_environment() works fine when policy has no reset method."""
+  v = FakeViewer(step_dt=0.01)
+  v.policy = lambda obs: obs  # plain callable, no reset attribute
+
+  v.reset_environment()  # should not raise
+
+
+# Formatting and status.
+
+
+def test_format_speed():
+  assert BaseViewer._format_speed(1.0) == "1x"
+  assert BaseViewer._format_speed(0.5) == "1/2x"
+  assert BaseViewer._format_speed(0.25) == "1/4x"
+  assert BaseViewer._format_speed(1 / 32) == "1/32x"
+
+
+def test_status_snapshot():
+  v = FakeViewer(step_dt=0.01)
+  v._fps = 60.0
+  v._sps = 50.0
+  v._last_error = "err"
+
+  status = v.get_status()
+  assert abs(status.actual_realtime - 0.5) < 1e-10
+  assert status.speed_label == "1x"
+  assert status.last_error == "err"
+
+
+def test_capped_clears_each_tick():
+  """Capped resets to False each tick; only True when deadline hit."""
+  v = FakeViewer(step_dt=0.01)
+  v.inject_tick(dt=0.02)
+  assert not v._was_capped
+
+  # Force capped state, then verify next tick clears it.
+  v._was_capped = True
+  v.inject_tick(dt=0.02)
+  assert not v._was_capped
+
+
+def test_capped_false_when_no_remaining_budget():
+  """Deadline hit with no remaining budget is NOT capped (transient stall)."""
+  v = FakeViewer(step_dt=0.01, frame_rate=60.0)
+  # dt=0.01 at 1x: budget=0.01, exactly 1 step, budget goes to 0.
+  # Even if deadline fires (via GC), no remaining work to drop.
+  v.inject_tick(dt=0.01)
+  assert not v._was_capped
+
+
+# Spiral protection.
+
+
+def test_no_spiral():
+  v = FakeViewer(step_dt=0.01, frame_rate=60.0)
+  v._speed_index = v.SPEED_MULTIPLIERS.index(8.0)
+  v._time_multiplier = 8.0
+
+  original = v._execute_step
+
+  def slow_step() -> bool:
+    time.sleep(0.005)
+    return original()
+
+  v._execute_step = slow_step  # type: ignore[assignment]
+
+  start = time.perf_counter()
+  v.inject_tick(dt=1.0 / 60.0)
+  elapsed = time.perf_counter() - start
+
+  assert elapsed < 0.05
+  assert v.sim_step_count < 13
+  assert v.sim_step_count >= 1
+  # Capped because slow steps + large budget means remaining work was dropped.
+  assert v._was_capped
diff --git a/tests/test_viser_conversions.py b/tests/test_viser_conversions.py
new file mode 100644
index 0000000..5ba4f5f
--- /dev/null
+++ b/tests/test_viser_conversions.py
@@ -0,0 +1,573 @@
+"""Test viser conversion functions with various robot models."""
+
+from pathlib import Path
+
+import mujoco
+
+from mjlab.viewer.viser import (
+  create_site_mesh,
+  get_geom_texture_id,
+  group_geoms_by_visual_compat,
+  merge_geoms,
+  merge_sites,
+  mujoco_mesh_to_trimesh,
+)
+
+
+def load_robot_model(robot_name: str) -> mujoco.MjModel:
+  """Load a robot model from the asset zoo."""
+  base_path = Path(__file__).parent.parent / "src/mjlab/asset_zoo/robots"
+
+  # Map robot names to their XML files.
+  robot_paths = {
+    "unitree_g1": base_path / "unitree_g1/xmls/g1.xml",
+    "unitree_go1": base_path / "unitree_go1/xmls/go1.xml",
+  }
+
+  if robot_name not in robot_paths:
+    raise ValueError(f"Unknown robot: {robot_name}")
+
+  xml_path = robot_paths[robot_name]
+  if not xml_path.exists():
+    raise FileNotFoundError(f"Robot XML not found: {xml_path}")
+
+  return mujoco.MjModel.from_xml_path(str(xml_path))
+
+
+def test_unitree_g1_conversion():
+  """Test conversion with Unitree G1 robot."""
+  model = load_robot_model("unitree_g1")
+
+  mesh_geom_count = 0
+  has_textures = False
+
+  for geom_idx in range(model.ngeom):
+    if model.geom_type[geom_idx] == mujoco.mjtGeom.mjGEOM_MESH:
+      mesh_geom_count += 1
+
+      # Convert to trimesh.
+      mesh = mujoco_mesh_to_trimesh(model, geom_idx)
+
+      # Basic checks.
+      assert mesh is not None, f"Failed to convert geom {geom_idx}"
+      assert len(mesh.vertices) > 0, f"Mesh {geom_idx} has no vertices"
+      assert len(mesh.faces) > 0, f"Mesh {geom_idx} has no faces"
+
+      # Check for textures.
+      if hasattr(mesh.visual, "uv"):
+        has_textures = True
+
+  assert mesh_geom_count > 0, "No mesh geometries found in Unitree G1"
+  print(f"✓ Unitree G1: Successfully converted {mesh_geom_count} mesh geometries")
+  if has_textures:
+    print("  - Found textured meshes")
+
+
+def test_unitree_go1_conversion():
+  """Test conversion with Unitree Go1 robot."""
+  model = load_robot_model("unitree_go1")
+
+  mesh_geom_count = 0
+  primitive_geom_count = 0
+
+  for geom_idx in range(model.ngeom):
+    geom_type = model.geom_type[geom_idx]
+
+    if geom_type == mujoco.mjtGeom.mjGEOM_MESH:
+      mesh_geom_count += 1
+
+      # Convert to trimesh.
+      mesh = mujoco_mesh_to_trimesh(model, geom_idx)
+
+      # Basic checks.
+      assert mesh is not None, f"Failed to convert geom {geom_idx}"
+      assert len(mesh.vertices) > 0, f"Mesh {geom_idx} has no vertices"
+      assert len(mesh.faces) > 0, f"Mesh {geom_idx} has no faces"
+    else:
+      # Count primitive geometries (box, sphere, capsule, etc.).
+      primitive_geom_count += 1
+
+  print(f"✓ Unitree Go1: Successfully converted {mesh_geom_count} mesh geometries")
+  print(f"  - Also has {primitive_geom_count} primitive geometries")
+
+
+def test_texture_extraction():
+  """Test texture extraction with a simple textured model."""
+  # Create a model with procedural texture.
+  xml_string = """
+    <mujoco>
+        <asset>
+            <!-- Procedural checker texture -->
+            <texture name="checker" type="2d" builtin="checker" width="64" height="64"
+                     rgb1="1 0 0" rgb2="0 0 1"/>
+            <material name="checker_mat" texture="checker" rgba="1 1 1 1"/>
+
+            <!-- Simple box mesh with 8 vertices -->
+            <mesh name="box"
+                  vertex="0 0 0  1 0 0  1 1 0  0 1 0  0 0 1  1 0 1  1 1 1  0 1 1"
+                  face="0 1 2  0 2 3  4 5 6  4 6 7"/>
+        </asset>
+
+        <worldbody>
+            <geom name="textured_mesh" type="mesh" mesh="box" material="checker_mat"/>
+        </worldbody>
+    </mujoco>
+    """
+
+  model = mujoco.MjModel.from_xml_string(xml_string)
+
+  # Find the mesh geom.
+  for geom_idx in range(model.ngeom):
+    if model.geom_type[geom_idx] == mujoco.mjtGeom.mjGEOM_MESH:
+      mesh = mujoco_mesh_to_trimesh(model, geom_idx)
+
+      assert mesh is not None, "Failed to convert textured mesh"
+      assert mesh.visual is not None, "Mesh has no visual"
+
+      # Check if texture was extracted (procedural textures should work).
+      matid = model.geom_matid[geom_idx]
+      if matid >= 0 and matid < model.nmat:
+        texid = model.mat_texid[matid]
+        # texid might be an array, get the first element if so.
+        if hasattr(texid, "__len__"):
+          texid = texid[0] if len(texid) > 0 else -1
+        if texid >= 0:
+          # Should have extracted the checker texture.
+          print("✓ Texture extraction: Successfully extracted procedural texture")
+          return
+
+  print("✓ Texture extraction: Tested (no textured meshes in simple model)")
+
+
+def test_material_colors():
+  """Test that material colors are properly applied."""
+  xml_string = """
+    <mujoco>
+        <asset>
+            <material name="red" rgba="1 0 0 1"/>
+            <material name="green" rgba="0 1 0 0.5"/>
+            <!-- Tetrahedron with 4 vertices (minimum for MuJoCo mesh) -->
+            <mesh name="tetra"
+                  vertex="0 0 0  1 0 0  0.5 0.866 0  0.5 0.289 0.816"
+                  face="0 1 2  0 1 3  0 2 3  1 2 3"/>
+        </asset>
+
+        <worldbody>
+            <geom name="red_mesh" type="mesh" mesh="tetra" material="red"/>
+            <geom name="green_mesh" type="mesh" mesh="tetra" material="green" pos="2 0 0"/>
+            <geom name="default_mesh" type="mesh" mesh="tetra" pos="4 0 0"/>
+        </worldbody>
+    </mujoco>
+    """
+
+  model = mujoco.MjModel.from_xml_string(xml_string)
+
+  colors_found = []
+  for geom_idx in range(model.ngeom):
+    if model.geom_type[geom_idx] == mujoco.mjtGeom.mjGEOM_MESH:
+      mesh = mujoco_mesh_to_trimesh(model, geom_idx)
+
+      # Check visual colors.
+      visual = mesh.visual
+      if visual and hasattr(visual, "vertex_colors"):
+        # Get the first vertex color (they should all be the same).
+        color = visual.vertex_colors[0]
+        colors_found.append(tuple(color))
+
+  assert len(colors_found) == 3, "Should have 3 meshes"
+
+  # Check that we got different colors.
+  assert colors_found[0][:3] == (255, 0, 0), "First mesh should be red"
+  assert colors_found[1][:3] == (0, 255, 0), "Second mesh should be green"
+  # Third mesh should have default color.
+
+  print("✓ Material colors: Correctly applied to meshes")
+
+
+def test_performance():
+  """Test conversion performance with a complex model."""
+  import time
+
+  model = load_robot_model("unitree_g1")
+
+  mesh_geoms = []
+  for geom_idx in range(model.ngeom):
+    if model.geom_type[geom_idx] == mujoco.mjtGeom.mjGEOM_MESH:
+      mesh_geoms.append(geom_idx)
+
+  start_time = time.time()
+  for geom_idx in mesh_geoms:
+    mujoco_mesh_to_trimesh(model, geom_idx)
+  elapsed = time.time() - start_time
+
+  avg_time = elapsed / len(mesh_geoms) * 1000  # Convert to ms.
+  print(f"✓ Performance: Converted {len(mesh_geoms)} meshes in {elapsed:.3f}s")
+  print(f"  - Average: {avg_time:.2f}ms per mesh")
+
+  # Warn if it's too slow.
+  if avg_time > 50:
+    print("  ⚠ Warning: Conversion is slow (>50ms per mesh)")
+
+
+def test_mesh_with_texture_coordinates():
+  """Test meshes with texture coordinates (Issue #225)."""
+  xml_string = """
+    <mujoco>
+        <asset>
+            <!-- Simple tetrahedron WITH texture coordinates -->
+            <mesh name="textured_tetra"
+                  vertex="0 0 0  1 0 0  0.5 0.866 0  0.5 0.289 0.816"
+                  texcoord="0 0  1 0  0.5 1  0.5 0.5"
+                  face="0 1 2  0 1 3  0 2 3  1 2 3"/>
+        </asset>
+        <worldbody>
+            <geom type="mesh" mesh="textured_tetra"/>
+        </worldbody>
+    </mujoco>
+    """
+
+  model = mujoco.MjModel.from_xml_string(xml_string)
+
+  # Verify the model has texture coordinates.
+  assert model.mesh_texcoord.shape == (4, 2), "Model should have 4 texture coordinates"
+  assert model.mesh_texcoordnum[0] == 4, "Mesh should have 4 texture coordinates"
+
+  # Convert the mesh.
+  mesh = mujoco_mesh_to_trimesh(model, 0)
+
+  # Verify the mesh was created successfully.
+  assert mesh is not None, "Failed to convert textured mesh"
+  assert len(mesh.vertices) > 0, "Mesh has no vertices"
+  assert len(mesh.faces) > 0, "Mesh has no faces"
+
+  # With texture coordinates, vertices are duplicated per face.
+  # 4 faces * 3 vertices per face = 12 vertices.
+  assert len(mesh.vertices) == 12, (
+    f"Expected 12 duplicated vertices, got {len(mesh.vertices)}"
+  )
+  assert len(mesh.faces) == 4, f"Expected 4 faces, got {len(mesh.faces)}"
+
+  print(
+    "✓ Mesh with texture coordinates: Successfully converted mesh with texcoords (Issue #225 fixed)"
+  )
+
+
+def _make_mixed_visual_model() -> mujoco.MjModel:
+  """Create a model with both textured and color-only geoms on the same body."""
+  xml = """
+    <mujoco>
+      <asset>
+        <texture name="checker" type="2d" builtin="checker" width="64" height="64"
+                 rgb1="1 0 0" rgb2="0 0 1"/>
+        <material name="tex_mat" texture="checker"/>
+        <material name="color_mat" rgba="0 1 0 1"/>
+        <mesh name="textured_tetra"
+              vertex="0 0 0  1 0 0  0.5 0.866 0  0.5 0.289 0.816"
+              texcoord="0 0  1 0  0.5 1  0.5 0.5"
+              face="0 1 2  0 1 3  0 2 3  1 2 3"/>
+        <mesh name="plain_tetra"
+              vertex="2 0 0  3 0 0  2.5 0.866 0  2.5 0.289 0.816"
+              face="0 1 2  0 1 3  0 2 3  1 2 3"/>
+      </asset>
+      <worldbody>
+        <body name="mixed">
+          <geom name="tex_geom" type="mesh" mesh="textured_tetra" material="tex_mat"/>
+          <geom name="color_geom" type="mesh" mesh="plain_tetra" material="color_mat"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+  return mujoco.MjModel.from_xml_string(xml)
+
+
+def test_get_geom_texture_id():
+  """Verify correct texture ID detection for textured vs untextured geoms."""
+  model = _make_mixed_visual_model()
+
+  # Find geom indices by name.
+  tex_geom_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_GEOM, "tex_geom")
+  color_geom_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_GEOM, "color_geom")
+
+  tex_id = get_geom_texture_id(model, tex_geom_id)
+  assert tex_id >= 0, "Textured geom should have a non-negative texture ID"
+
+  color_id = get_geom_texture_id(model, color_geom_id)
+  assert color_id == -1, "Color-only geom should have texture ID -1"
+
+
+def test_get_geom_texture_id_primitive():
+  """Primitive (non-mesh) geoms should always return -1."""
+  xml = """
+    <mujoco>
+      <worldbody>
+        <geom name="sphere" type="sphere" size="0.1"/>
+      </worldbody>
+    </mujoco>
+  """
+  model = mujoco.MjModel.from_xml_string(xml)
+  geom_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_GEOM, "sphere")
+  assert get_geom_texture_id(model, geom_id) == -1
+
+
+def test_group_geoms_by_visual_compat():
+  """Verify geoms are correctly partitioned by visual compatibility."""
+  model = _make_mixed_visual_model()
+
+  tex_geom_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_GEOM, "tex_geom")
+  color_geom_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_GEOM, "color_geom")
+
+  groups = group_geoms_by_visual_compat(model, [tex_geom_id, color_geom_id])
+
+  # Should produce two groups: one textured, one untextured.
+  assert len(groups) == 2, f"Expected 2 groups, got {len(groups)}"
+
+  # Each group should have exactly one geom.
+  assert all(len(g) == 1 for g in groups)
+
+  # Flatten to a set and verify all geoms are present.
+  all_ids = {gid for g in groups for gid in g}
+  assert all_ids == {tex_geom_id, color_geom_id}
+
+
+def test_group_geoms_single_type():
+  """All untextured geoms should land in a single group."""
+  xml = """
+    <mujoco>
+      <asset>
+        <material name="red" rgba="1 0 0 1"/>
+        <material name="blue" rgba="0 0 1 1"/>
+        <mesh name="t1"
+              vertex="0 0 0  1 0 0  0.5 0.866 0  0.5 0.289 0.816"
+              face="0 1 2  0 1 3  0 2 3  1 2 3"/>
+        <mesh name="t2"
+              vertex="2 0 0  3 0 0  2.5 0.866 0  2.5 0.289 0.816"
+              face="0 1 2  0 1 3  0 2 3  1 2 3"/>
+      </asset>
+      <worldbody>
+        <body name="b">
+          <geom name="g1" type="mesh" mesh="t1" material="red"/>
+          <geom name="g2" type="mesh" mesh="t2" material="blue"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+  model = mujoco.MjModel.from_xml_string(xml)
+  g1 = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_GEOM, "g1")
+  g2 = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_GEOM, "g2")
+
+  groups = group_geoms_by_visual_compat(model, [g1, g2])
+  assert len(groups) == 1, "Two untextured geoms should form a single group"
+  assert set(groups[0]) == {g1, g2}
+
+
+def test_merge_mixed_visual_geoms():
+  """Regression: merging each visual-compat subgroup must preserve visuals."""
+  import trimesh.visual
+
+  model = _make_mixed_visual_model()
+
+  tex_geom_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_GEOM, "tex_geom")
+  color_geom_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_GEOM, "color_geom")
+
+  groups = group_geoms_by_visual_compat(model, [tex_geom_id, color_geom_id])
+
+  for group in groups:
+    mesh = merge_geoms(model, group)
+    assert len(mesh.vertices) > 0
+    assert len(mesh.faces) > 0
+
+    tex_id = get_geom_texture_id(model, group[0])
+    if tex_id >= 0:
+      # Textured group should have TextureVisuals, not default gray.
+      assert isinstance(mesh.visual, trimesh.visual.TextureVisuals), (
+        f"Expected TextureVisuals for textured group, got {type(mesh.visual)}"
+      )
+    else:
+      # Color group should have ColorVisuals.
+      assert isinstance(mesh.visual, trimesh.visual.ColorVisuals), (
+        f"Expected ColorVisuals for color group, got {type(mesh.visual)}"
+      )
+      # Verify the color is green (not default gray).
+      vertex_colors = mesh.visual.vertex_colors
+      assert vertex_colors[0][1] == 255, (
+        f"Expected green channel 255, got {vertex_colors[0][1]}"
+      )
+
+
+def _make_site_model() -> mujoco.MjModel:
+  """Create a model with all 5 site types."""
+  xml = """
+    <mujoco>
+      <worldbody>
+        <body name="test_body" pos="0 0 1">
+          <joint type="free"/>
+          <geom type="sphere" size="0.01"/>
+          <site name="sphere_site" type="sphere" size="0.1" rgba="1 0 0 1"/>
+          <site name="capsule_site" type="capsule" size="0.05 0.1" rgba="0 1 0 1"
+                pos="1 0 0"/>
+          <site name="ellipsoid_site" type="ellipsoid" size="0.1 0.05 0.03"
+                rgba="0 0 1 1" pos="2 0 0"/>
+          <site name="cylinder_site" type="cylinder" size="0.05 0.1" rgba="1 1 0 1"
+                pos="3 0 0"/>
+          <site name="box_site" type="box" size="0.1 0.05 0.03" rgba="0 1 1 1"
+                pos="4 0 0"/>
+        </body>
+      </worldbody>
+    </mujoco>
+  """
+  return mujoco.MjModel.from_xml_string(xml)
+
+
+def test_create_site_mesh_sphere():
+  """Test sphere site mesh creation."""
+  model = _make_site_model()
+  site_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_SITE, "sphere_site")
+  mesh = create_site_mesh(model, site_id)
+  assert len(mesh.vertices) > 0
+  assert len(mesh.faces) > 0
+  # Check color is red.
+  assert mesh.visual is not None
+  assert mesh.visual.vertex_colors[0][0] == 255
+  assert mesh.visual.vertex_colors[0][1] == 0
+
+
+def test_create_site_mesh_capsule():
+  """Test capsule site mesh creation."""
+  model = _make_site_model()
+  site_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_SITE, "capsule_site")
+  mesh = create_site_mesh(model, site_id)
+  assert len(mesh.vertices) > 0
+  assert len(mesh.faces) > 0
+  # Check color is green.
+  assert mesh.visual is not None
+  assert mesh.visual.vertex_colors[0][1] == 255
+
+
+def test_create_site_mesh_ellipsoid():
+  """Test ellipsoid site mesh creation."""
+  model = _make_site_model()
+  site_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_SITE, "ellipsoid_site")
+  mesh = create_site_mesh(model, site_id)
+  assert len(mesh.vertices) > 0
+  assert len(mesh.faces) > 0
+  # Check color is blue.
+  assert mesh.visual is not None
+  assert mesh.visual.vertex_colors[0][2] == 255
+
+
+def test_create_site_mesh_cylinder():
+  """Test cylinder site mesh creation."""
+  model = _make_site_model()
+  site_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_SITE, "cylinder_site")
+  mesh = create_site_mesh(model, site_id)
+  assert len(mesh.vertices) > 0
+  assert len(mesh.faces) > 0
+
+
+def test_create_site_mesh_box():
+  """Test box site mesh creation."""
+  model = _make_site_model()
+  site_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_SITE, "box_site")
+  mesh = create_site_mesh(model, site_id)
+  assert len(mesh.vertices) > 0
+  assert len(mesh.faces) > 0
+
+
+def test_create_site_mesh_rgba_fallback():
+  """Test that all-zero RGBA falls back to gray."""
+  xml = """
+    <mujoco>
+      <worldbody>
+        <site name="zero_rgba" type="sphere" size="0.1" rgba="0 0 0 0"/>
+      </worldbody>
+    </mujoco>
+  """
+  model = mujoco.MjModel.from_xml_string(xml)
+  site_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_SITE, "zero_rgba")
+  mesh = create_site_mesh(model, site_id)
+  # Should be gray (0.5 * 255 = 127), not transparent black.
+  assert mesh.visual is not None
+  color = mesh.visual.vertex_colors[0]
+  assert color[0] == 127, f"Expected R=127, got {color[0]}"
+  assert color[1] == 127, f"Expected G=127, got {color[1]}"
+  assert color[2] == 127, f"Expected B=127, got {color[2]}"
+  assert color[3] == 255, f"Expected A=255, got {color[3]}"
+
+
+def test_merge_sites_single():
+  """Test merging a single site returns the site mesh."""
+  model = _make_site_model()
+  site_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_SITE, "sphere_site")
+  mesh = merge_sites(model, [site_id])
+  assert len(mesh.vertices) > 0
+  assert len(mesh.faces) > 0
+
+
+def test_merge_sites_multiple():
+  """Test merging multiple sites combines them correctly."""
+  model = _make_site_model()
+  sphere_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_SITE, "sphere_site")
+  capsule_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_SITE, "capsule_site")
+  box_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_SITE, "box_site")
+
+  single_sphere = create_site_mesh(model, sphere_id)
+  single_capsule = create_site_mesh(model, capsule_id)
+  single_box = create_site_mesh(model, box_id)
+
+  merged = merge_sites(model, [sphere_id, capsule_id, box_id])
+
+  # Merged mesh should have at least the sum of individual vertices.
+  expected_min_verts = (
+    len(single_sphere.vertices)
+    + len(single_capsule.vertices)
+    + len(single_box.vertices)
+  )
+  assert len(merged.vertices) >= expected_min_verts, (
+    f"Expected >= {expected_min_verts} vertices, got {len(merged.vertices)}"
+  )
+  assert len(merged.faces) > 0
+
+
+if __name__ == "__main__":
+  # Run all tests
+  print("=" * 60)
+  print("Testing Viser Conversions")
+  print("=" * 60)
+
+  tests = [
+    test_unitree_g1_conversion,
+    test_unitree_go1_conversion,
+    test_texture_extraction,
+    test_material_colors,
+    test_performance,
+    test_mesh_with_texture_coordinates,
+    test_get_geom_texture_id,
+    test_get_geom_texture_id_primitive,
+    test_group_geoms_by_visual_compat,
+    test_group_geoms_single_type,
+    test_merge_mixed_visual_geoms,
+  ]
+
+  failed = []
+  for test in tests:
+    try:
+      test()
+    except Exception as e:
+      test_name = test.__name__ if hasattr(test, "__name__") else str(test)
+      print(f"✗ {test_name}: {e}")
+      import traceback
+
+      traceback.print_exc()
+      failed.append(test_name)
+
+  print("\n" + "=" * 60)
+  if failed:
+    print(f"Failed tests: {', '.join(failed)}")
+    import sys
+
+    sys.exit(1)
+  else:
+    print("All tests passed!")
+    import sys
+
+    sys.exit(0)
diff --git a/tests/test_viser_update_policy.py b/tests/test_viser_update_policy.py
new file mode 100644
index 0000000..b478c2f
--- /dev/null
+++ b/tests/test_viser_update_policy.py
@@ -0,0 +1,116 @@
+"""Tests for Viser viewer update-policy helpers."""
+
+from dataclasses import dataclass
+from typing import Any
+from unittest.mock import MagicMock
+
+import mujoco
+from mjviser import ViserMujocoScene
+
+from mjlab.viewer.viser.overlays import ViserContactOverlays, ViserDebugOverlays
+from mjlab.viewer.viser.viewer import ViserPlayViewer
+
+
+@dataclass
+class _DummyScene:
+  env_idx: int
+  debug_visualization_enabled: bool
+  show_contact_points: bool = False
+  show_contact_forces: bool = False
+  needs_update: bool = False
+  clear_count: int = 0
+  clear_debug_count: int = 0
+
+  def clear(self) -> None:
+    self.clear_count += 1
+
+  def clear_debug_all(self) -> None:
+    self.clear_debug_count += 1
+
+
+class _DummyEnv:
+  def __init__(self, unwrapped: Any):
+    self._unwrapped = unwrapped
+
+  @property
+  def unwrapped(self) -> Any:
+    return self._unwrapped
+
+
+def test_should_update_cameras():
+  assert ViserPlayViewer._should_update_cameras(paused=False, has_pending_updates=False)
+  assert not ViserPlayViewer._should_update_cameras(
+    paused=True, has_pending_updates=False
+  )
+  assert ViserPlayViewer._should_update_cameras(paused=True, has_pending_updates=True)
+
+
+def test_should_submit_scene_update():
+  # Odd ticks are skipped to keep scene submits around 30Hz.
+  assert not ViserPlayViewer._should_submit_scene_update(
+    counter=1, paused=False, has_pending_updates=True
+  )
+  # Running: submit on even ticks regardless of pending flags.
+  assert ViserPlayViewer._should_submit_scene_update(
+    counter=2, paused=False, has_pending_updates=False
+  )
+  # Paused: submit only with pending updates.
+  assert not ViserPlayViewer._should_submit_scene_update(
+    counter=2, paused=True, has_pending_updates=False
+  )
+  assert ViserPlayViewer._should_submit_scene_update(
+    counter=2, paused=True, has_pending_updates=True
+  )
+
+
+def test_scene_requires_live_refresh():
+  """Base scene sets needs_update when contact overlays are visible."""
+  model = mujoco.MjModel.from_xml_string("<mujoco><worldbody/></mujoco>")
+  server = MagicMock()
+  scene = ViserMujocoScene(server, model, num_envs=1)
+
+  scene.show_contact_points = False
+  scene.show_contact_forces = False
+  scene.needs_update = False
+  scene._last_body_xpos = None  # No cached data, refresh is a no-op.
+  scene.refresh_visualization()
+  assert not scene.needs_update
+
+  scene.show_contact_points = True
+  assert scene.show_contact_points or scene.show_contact_forces
+
+
+def test_debug_overlays_env_switch_and_queue():
+  """env_switch respects enabled flag; queue clears + calls update_visualizers."""
+  unwrapped = MagicMock(spec=["update_visualizers"])
+  env = _DummyEnv(unwrapped)
+  scene = _DummyScene(env_idx=0, debug_visualization_enabled=False)
+  overlays = ViserDebugOverlays(env=env, scene=scene)
+
+  # Disabled: env switch does not clear.
+  overlays.on_env_switch()
+  assert scene.clear_debug_count == 0
+
+  # Enabled: env switch clears, queue dispatches.
+  scene.debug_visualization_enabled = True
+  overlays.on_env_switch()
+  assert scene.clear_debug_count == 1
+
+  overlays.queue()
+  assert scene.clear_count == 1
+  unwrapped.update_visualizers.assert_called_once_with(scene)
+
+
+def test_contact_overlays_env_switch():
+  """env_switch requests scene update only when contacts are enabled."""
+  scene = _DummyScene(env_idx=0, debug_visualization_enabled=False)
+  overlays = ViserContactOverlays(scene=scene)
+
+  assert not overlays.is_enabled()
+  overlays.on_env_switch()
+  assert not scene.needs_update
+
+  scene.show_contact_points = True
+  assert overlays.is_enabled()
+  overlays.on_env_switch()
+  assert scene.needs_update
diff --git a/tests/test_xml_actuator.py b/tests/test_xml_actuator.py
new file mode 100644
index 0000000..02cf9ac
--- /dev/null
+++ b/tests/test_xml_actuator.py
@@ -0,0 +1,178 @@
+"""Tests for XML actuator wrappers."""
+
+import mujoco
+import pytest
+from conftest import get_test_device
+
+from mjlab.actuator import XmlActuator, XmlActuatorCfg
+from mjlab.entity import Entity, EntityArticulationInfoCfg, EntityCfg
+from mjlab.envs import ManagerBasedRlEnv, ManagerBasedRlEnvCfg, mdp
+from mjlab.managers.observation_manager import ObservationGroupCfg, ObservationTermCfg
+from mjlab.scene import SceneCfg
+from mjlab.sim import MujocoCfg, SimulationCfg
+from mjlab.terrains import TerrainEntityCfg
+
+# Robot with 2 joints but only 1 actuator defined (underactuated).
+ROBOT_XML_UNDERACTUATED = """
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="1.0"/>
+      <body name="link1" pos="0 0 0">
+        <joint name="joint1" type="hinge" axis="0 0 1" range="-1.57 1.57"/>
+        <geom name="link1_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+      </body>
+      <body name="link2" pos="0 0 0">
+        <joint name="joint2" type="hinge" axis="0 0 1" range="-1.57 1.57"/>
+        <geom name="link2_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+      </body>
+    </body>
+  </worldbody>
+  <actuator>
+    <motor name="actuator1" joint="joint2" gear="1.0"/>
+  </actuator>
+</mujoco>
+"""
+
+
+@pytest.fixture(scope="module")
+def device():
+  return get_test_device()
+
+
+def test_xml_actuator_underactuated_with_wildcard():
+  """XmlActuator filters to joints with XML actuators when using wildcard."""
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML_UNDERACTUATED),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(XmlActuatorCfg(target_names_expr=(".*",)),)
+    ),
+  )
+  entity = Entity(cfg)
+  entity.compile()
+
+  # Should only control joint2 (which has an XML actuator), not joint1.
+  assert len(entity._actuators) == 1
+  actuator = entity._actuators[0]
+  assert actuator._target_names == ["joint2"]
+
+
+def test_xml_actuator_no_matching_actuators_raises_error():
+  """XmlActuator raises error when no targets have matching XML actuators."""
+  with pytest.raises(
+    ValueError, match="No XML actuators found for any targets matching the patterns"
+  ):
+    cfg = EntityCfg(
+      spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML_UNDERACTUATED),
+      articulation=EntityArticulationInfoCfg(
+        actuators=(XmlActuatorCfg(target_names_expr=("joint1",)),)
+      ),
+    )
+    entity = Entity(cfg)
+    entity.compile()
+
+
+def test_joint_action_underactuated_with_wildcard(device):
+  """JointAction with wildcard pattern matches only actuated joints."""
+  robot_cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML_UNDERACTUATED),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(XmlActuatorCfg(target_names_expr=(".*",)),)
+    ),
+  )
+
+  env_cfg = ManagerBasedRlEnvCfg(
+    scene=SceneCfg(
+      terrain=TerrainEntityCfg(terrain_type="plane"),
+      num_envs=1,
+      extent=1.0,
+      entities={"robot": robot_cfg},
+    ),
+    observations={
+      "actor": ObservationGroupCfg(
+        terms={
+          "joint_pos": ObservationTermCfg(
+            func=lambda env: env.scene["robot"].data.joint_pos
+          ),
+        },
+      ),
+    },
+    actions={
+      "joint_effort": mdp.JointEffortActionCfg(
+        entity_name="robot", actuator_names=(".*",), scale=1.0
+      )
+    },
+    sim=SimulationCfg(mujoco=MujocoCfg(timestep=0.01, iterations=1)),
+    decimation=1,
+    episode_length_s=1.0,
+  )
+
+  env = ManagerBasedRlEnv(cfg=env_cfg, device=device)
+  action_term = env.action_manager._terms["joint_effort"]
+  assert isinstance(action_term, mdp.JointEffortAction)
+
+  # Wildcard should resolve to only actuated joint (joint2), not all joints.
+  assert action_term.action_dim == 1
+  assert action_term.target_names == ["joint2"]
+  assert action_term.target_ids.tolist() == [1]
+
+  env.close()
+
+
+# Robot with a "general" actuator (hand-tuned gainprm/biasprm that don't match
+# any standard pattern). Strict auto-detection would reject this.
+ROBOT_XML_GENERAL_ACTUATOR = """
+<mujoco>
+  <worldbody>
+    <body name="base" pos="0 0 1">
+      <freejoint name="free_joint"/>
+      <geom name="base_geom" type="box" size="0.2 0.2 0.1" mass="1.0"/>
+      <body name="link1" pos="0 0 0">
+        <joint name="joint1" type="hinge" axis="0 0 1" range="-1.57 1.57"/>
+        <geom name="link1_geom" type="box" size="0.1 0.1 0.1" mass="0.1"/>
+      </body>
+    </body>
+  </worldbody>
+  <actuator>
+    <general name="custom_act" joint="joint1"
+             gaintype="fixed" biastype="affine"
+             gainprm="10" biasprm="5 -3 -1"/>
+  </actuator>
+</mujoco>
+"""
+
+
+def test_xml_actuator_explicit_command_field_bypasses_detection():
+  """Explicit command_field allows non-standard XML actuators."""
+  cfg = EntityCfg(
+    spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML_GENERAL_ACTUATOR),
+    articulation=EntityArticulationInfoCfg(
+      actuators=(
+        XmlActuatorCfg(
+          target_names_expr=("joint1",),
+          command_field="effort",
+        ),
+      )
+    ),
+  )
+  entity = Entity(cfg)
+  entity.compile()
+
+  actuator = entity._actuators[0]
+  assert isinstance(actuator, XmlActuator)
+  assert actuator.command_field == "effort"
+  assert actuator._target_names == ["joint1"]
+
+
+def test_xml_actuator_auto_detection_rejects_general_actuator():
+  """Auto-detection raises for non-standard actuators when command_field is None."""
+  with pytest.raises(ValueError, match="Cannot determine command field"):
+    cfg = EntityCfg(
+      spec_fn=lambda: mujoco.MjSpec.from_string(ROBOT_XML_GENERAL_ACTUATOR),
+      articulation=EntityArticulationInfoCfg(
+        actuators=(XmlActuatorCfg(target_names_expr=("joint1",)),)
+      ),
+    )
+    entity = Entity(cfg)
+    entity.compile()
diff --git a/tests/test_xml_utils.py b/tests/test_xml_utils.py
new file mode 100644
index 0000000..22d3ed6
--- /dev/null
+++ b/tests/test_xml_utils.py
@@ -0,0 +1,116 @@
+"""Tests for mjlab.utils.xml."""
+
+import zipfile
+
+import mujoco
+import numpy as np
+
+from mjlab.utils.xml import fix_spec_xml, strip_buffer_textures
+
+
+def test_strip_buffer_textures():
+  """Stripping buffer textures removes them and enables XML roundtrip."""
+  spec = mujoco.MjSpec()
+  body = spec.worldbody.add_body(name="terrain")
+
+  tex = spec.add_texture(
+    name="hf_tex",
+    type=mujoco.mjtTexture.mjTEXTURE_2D,
+    width=2,
+    height=2,
+  )
+  tex.data = (np.ones((2, 2, 3), dtype=np.uint8) * 128).tobytes()
+
+  mat = spec.add_material(name="hf_mat")
+  mat.textures[mujoco.mjtTextureRole.mjTEXROLE_RGB] = "hf_tex"
+
+  hf = spec.add_hfield(name="hf", nrow=4, ncol=4, size=[1, 1, 0.1, 0.01])
+  hf.userdata = np.zeros(16).tolist()
+  body.add_geom(
+    type=mujoco.mjtGeom.mjGEOM_HFIELD,
+    hfieldname="hf",
+    material="hf_mat",
+  )
+
+  strip_buffer_textures(spec)
+
+  assert len(spec.textures) == 0
+  assert len(spec.materials) == 0
+  assert spec.geoms[0].material == ""
+
+  # XML roundtrip should succeed now.
+  model = mujoco.MjModel.from_xml_string(spec.to_xml())
+  assert model.nhfield == 1
+
+
+def test_fix_spec_xml():
+  """Removes empty defaults and optionally injects meshdir."""
+  xml = (
+    "<mujoco>\n"
+    "  <compiler/>\n"
+    "  <default/>\n"
+    '  <default class="foo/bar"/>\n'
+    "  <worldbody/>\n"
+    "</mujoco>\n"
+  )
+  result = fix_spec_xml(xml, meshdir="assets")
+
+  assert "<default/>" not in result
+  assert 'class="foo/bar"' not in result
+  assert 'meshdir="assets"' in result
+  assert "meshdir" not in fix_spec_xml(xml)
+
+
+def test_rough_terrain_write_xml_roundtrip(tmp_path):
+  """Export terrain with hfield via Entity.write_xml, reload as MjModel."""
+  from mjlab.terrains.heightfield_terrains import (
+    HfRandomUniformTerrainCfg,
+  )
+  from mjlab.terrains.terrain_entity import TerrainEntity, TerrainEntityCfg
+  from mjlab.terrains.terrain_generator import TerrainGeneratorCfg
+
+  terrain = TerrainEntity(
+    TerrainEntityCfg(
+      terrain_type="generator",
+      terrain_generator=TerrainGeneratorCfg(
+        size=(2.0, 2.0),
+        num_rows=1,
+        num_cols=1,
+        sub_terrains={
+          "rough": HfRandomUniformTerrainCfg(
+            proportion=1.0,
+            noise_range=(-0.05, 0.05),
+            noise_step=0.005,
+          ),
+        },
+      ),
+    ),
+    device="cpu",
+  )
+  xml_path = tmp_path / "terrain.xml"
+  terrain.write_xml(xml_path)
+
+  model = mujoco.MjModel.from_xml_path(str(xml_path))
+  assert model.nhfield == 1
+
+
+def test_scene_write_zip(tmp_path):
+  """Scene.write produces a directory; with zip=True, a zip archive."""
+  from mjlab.scene.scene import Scene, SceneCfg
+
+  scene = Scene(SceneCfg(), device="cpu")
+
+  # Directory export.
+  dir_out = tmp_path / "scene_dir"
+  scene.write(dir_out)
+  assert (dir_out / "scene.xml").exists()
+  mujoco.MjModel.from_xml_path(str(dir_out / "scene.xml"))
+
+  # Zip export.
+  zip_out = tmp_path / "scene_pkg"
+  scene.write(zip_out, zip=True)
+  zip_path = zip_out.with_suffix(".zip")
+  assert zip_path.exists()
+  assert not zip_out.exists()
+  with zipfile.ZipFile(zip_path) as zf:
+    assert "scene.xml" in zf.namelist()
diff --git a/typings/generate_mujoco_stubs.sh b/typings/generate_mujoco_stubs.sh
new file mode 100644
index 0000000..e7bd415
--- /dev/null
+++ b/typings/generate_mujoco_stubs.sh
@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+
+# Generate type stubs for MuJoCo using pybind11-stubgen.
+# This helps suppress pyright/ty errors for MuJoCo's C++ bindings.
+#
+# The output is post-processed by postprocess_stubs.py to make it
+# platform-independent (it drops the OpenGL backend stubs, which differ between
+# macOS and Linux). This keeps the committed stubs identical on every platform,
+# so CI can regenerate them and fail if they drift from the installed mujoco
+# version. pybind11-stubgen is pinned so its output is reproducible.
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# --no-sync runs in the already-synced project environment (so mujoco is
+# importable) without disturbing it; the conflicting cpu/cu128 extras mean a
+# plain "uv run" would re-sync and churn the environment.
+STUBGEN_VERSION="2.5.5"
+STUBGEN=(uv run --no-sync --with "pybind11-stubgen==${STUBGEN_VERSION}" pybind11-stubgen)
+
+echo "Generating MuJoCo type stubs..."
+"${STUBGEN[@]}" mujoco -o "$SCRIPT_DIR" --ignore-all-errors
+
+# mujoco.viewer pulls in GLFW, which may not import on a headless machine.
+# Skip it in that case rather than failing; the committed viewer stub is kept.
+if ! "${STUBGEN[@]}" mujoco.viewer -o "$SCRIPT_DIR" --ignore-all-errors; then
+  echo "Warning: could not generate mujoco.viewer stubs (no GLFW?). Skipping."
+fi
+
+echo "Post-processing stubs to make them platform-independent..."
+uv run --no-sync python "$SCRIPT_DIR/postprocess_stubs.py"
+
+echo "MuJoCo stubs generated successfully in $SCRIPT_DIR/mujoco/"
diff --git a/typings/mujoco/__init__.pyi b/typings/mujoco/__init__.pyi
new file mode 100644
index 0000000..3a85520
--- /dev/null
+++ b/typings/mujoco/__init__.pyi
@@ -0,0 +1,594 @@
+"""
+Python bindings for MuJoCo.
+"""
+from __future__ import annotations
+import ctypes as ctypes
+from mujoco._callbacks import get_mjcb_act_bias
+from mujoco._callbacks import get_mjcb_act_dyn
+from mujoco._callbacks import get_mjcb_act_gain
+from mujoco._callbacks import get_mjcb_contactfilter
+from mujoco._callbacks import get_mjcb_control
+from mujoco._callbacks import get_mjcb_passive
+from mujoco._callbacks import get_mjcb_sensor
+from mujoco._callbacks import get_mjcb_time
+from mujoco._callbacks import get_mju_user_free
+from mujoco._callbacks import get_mju_user_malloc
+from mujoco._callbacks import get_mju_user_warning
+from mujoco._callbacks import set_mjcb_act_bias
+from mujoco._callbacks import set_mjcb_act_dyn
+from mujoco._callbacks import set_mjcb_act_gain
+from mujoco._callbacks import set_mjcb_contactfilter
+from mujoco._callbacks import set_mjcb_control
+from mujoco._callbacks import set_mjcb_passive
+from mujoco._callbacks import set_mjcb_sensor
+from mujoco._callbacks import set_mjcb_time
+from mujoco._callbacks import set_mju_user_free
+from mujoco._callbacks import set_mju_user_malloc
+from mujoco._callbacks import set_mju_user_warning
+from mujoco._enums import mjrIndexType
+from mujoco._enums import mjrMeshPrimitiveType
+from mujoco._enums import mjrPixelFormat
+from mujoco._enums import mjrVertexAttributeType
+from mujoco._enums import mjrVertexAttributeUsage
+from mujoco._enums import mjtAlignFree
+from mujoco._enums import mjtBias
+from mujoco._enums import mjtBuiltin
+from mujoco._enums import mjtButton
+from mujoco._enums import mjtCTimer
+from mujoco._enums import mjtCamLight
+from mujoco._enums import mjtCamOutBit
+from mujoco._enums import mjtCamera
+from mujoco._enums import mjtCatBit
+from mujoco._enums import mjtColorSpace
+from mujoco._enums import mjtConDataField
+from mujoco._enums import mjtCone
+from mujoco._enums import mjtConflict
+from mujoco._enums import mjtConstraint
+from mujoco._enums import mjtConstraintState
+from mujoco._enums import mjtCtrlChart
+from mujoco._enums import mjtDataType
+from mujoco._enums import mjtDepthMap
+from mujoco._enums import mjtDisableBit
+from mujoco._enums import mjtDyn
+from mujoco._enums import mjtEnableBit
+from mujoco._enums import mjtEq
+from mujoco._enums import mjtEvent
+from mujoco._enums import mjtFlexSelf
+from mujoco._enums import mjtFont
+from mujoco._enums import mjtFontScale
+from mujoco._enums import mjtFrame
+from mujoco._enums import mjtFramebuffer
+from mujoco._enums import mjtGain
+from mujoco._enums import mjtGeom
+from mujoco._enums import mjtGeomInertia
+from mujoco._enums import mjtGridPos
+from mujoco._enums import mjtInertiaFromGeom
+from mujoco._enums import mjtIntegrator
+from mujoco._enums import mjtItem
+from mujoco._enums import mjtJacobian
+from mujoco._enums import mjtJoint
+from mujoco._enums import mjtLRMode
+from mujoco._enums import mjtLabel
+from mujoco._enums import mjtLightType
+from mujoco._enums import mjtLimited
+from mujoco._enums import mjtLogLevel
+from mujoco._enums import mjtLogTopic
+from mujoco._enums import mjtMark
+from mujoco._enums import mjtMeshBuiltin
+from mujoco._enums import mjtMeshInertia
+from mujoco._enums import mjtMouse
+from mujoco._enums import mjtObj
+from mujoco._enums import mjtOrientation
+from mujoco._enums import mjtPertBit
+from mujoco._enums import mjtPluginCapabilityBit
+from mujoco._enums import mjtProjection
+from mujoco._enums import mjtRayDataField
+from mujoco._enums import mjtRndFlag
+from mujoco._enums import mjtSDFType
+from mujoco._enums import mjtSameFrame
+from mujoco._enums import mjtSection
+from mujoco._enums import mjtSensor
+from mujoco._enums import mjtSleepPolicy
+from mujoco._enums import mjtSleepState
+from mujoco._enums import mjtSolver
+from mujoco._enums import mjtStage
+from mujoco._enums import mjtState
+from mujoco._enums import mjtStereo
+from mujoco._enums import mjtTexture
+from mujoco._enums import mjtTextureRole
+from mujoco._enums import mjtTimer
+from mujoco._enums import mjtTrn
+from mujoco._enums import mjtVisFlag
+from mujoco._enums import mjtWarning
+from mujoco._enums import mjtWrap
+from mujoco._functions import mj_Euler
+from mujoco._functions import mj_RungeKutta
+from mujoco._functions import mj_actuatorInputName
+from mujoco._functions import mj_addContact
+from mujoco._functions import mj_addM
+from mujoco._functions import mj_angmomMat
+from mujoco._functions import mj_applyFT
+from mujoco._functions import mj_camlight
+from mujoco._functions import mj_checkAcc
+from mujoco._functions import mj_checkPos
+from mujoco._functions import mj_checkVel
+from mujoco._functions import mj_clearCache
+from mujoco._functions import mj_collision
+from mujoco._functions import mj_comPos
+from mujoco._functions import mj_comVel
+from mujoco._functions import mj_compareFwdInv
+from mujoco._functions import mj_constraintUpdate
+from mujoco._functions import mj_contactForce
+from mujoco._functions import mj_copyData
+from mujoco._functions import mj_copyState
+from mujoco._functions import mj_crb
+from mujoco._functions import mj_defaultLROpt
+from mujoco._functions import mj_defaultOption
+from mujoco._functions import mj_defaultSolRefImp
+from mujoco._functions import mj_defaultVisual
+from mujoco._functions import mj_differentiatePos
+from mujoco._functions import mj_energyPos
+from mujoco._functions import mj_energyVel
+from mujoco._functions import mj_extractState
+from mujoco._functions import mj_factorM
+from mujoco._functions import mj_flex
+from mujoco._functions import mj_forward
+from mujoco._functions import mj_forwardSkip
+from mujoco._functions import mj_fullM
+from mujoco._functions import mj_fwdAcceleration
+from mujoco._functions import mj_fwdActuation
+from mujoco._functions import mj_fwdConstraint
+from mujoco._functions import mj_fwdKinematics
+from mujoco._functions import mj_fwdPosition
+from mujoco._functions import mj_fwdVelocity
+from mujoco._functions import mj_geomDistance
+from mujoco._functions import mj_getCache
+from mujoco._functions import mj_getCacheCapacity
+from mujoco._functions import mj_getCacheSize
+from mujoco._functions import mj_getState
+from mujoco._functions import mj_getTotalmass
+from mujoco._functions import mj_id2name
+from mujoco._functions import mj_implicit
+from mujoco._functions import mj_initCtrlHistory
+from mujoco._functions import mj_initSensorHistory
+from mujoco._functions import mj_integratePos
+from mujoco._functions import mj_invConstraint
+from mujoco._functions import mj_invPosition
+from mujoco._functions import mj_invVelocity
+from mujoco._functions import mj_inverse
+from mujoco._functions import mj_inverseSkip
+from mujoco._functions import mj_isDual
+from mujoco._functions import mj_isPyramidal
+from mujoco._functions import mj_isSparse
+from mujoco._functions import mj_island
+from mujoco._functions import mj_jac
+from mujoco._functions import mj_jacBody
+from mujoco._functions import mj_jacBodyCom
+from mujoco._functions import mj_jacDot
+from mujoco._functions import mj_jacGeom
+from mujoco._functions import mj_jacPointAxis
+from mujoco._functions import mj_jacSite
+from mujoco._functions import mj_jacSubtreeCom
+from mujoco._functions import mj_kinematics
+from mujoco._functions import mj_loadAllPluginLibraries
+from mujoco._functions import mj_loadPluginLibrary
+from mujoco._functions import mj_local2Global
+from mujoco._functions import mj_makeConstraint
+from mujoco._functions import mj_makeM
+from mujoco._functions import mj_maxContact
+from mujoco._functions import mj_mulJacTVec
+from mujoco._functions import mj_mulJacVec
+from mujoco._functions import mj_mulM
+from mujoco._functions import mj_mulM2
+from mujoco._functions import mj_multiRay
+from mujoco._functions import mj_name2id
+from mujoco._functions import mj_normalizeQuat
+from mujoco._functions import mj_objectAcceleration
+from mujoco._functions import mj_objectVelocity
+from mujoco._functions import mj_passive
+from mujoco._functions import mj_printData
+from mujoco._functions import mj_printFormattedData
+from mujoco._functions import mj_printFormattedModel
+from mujoco._functions import mj_printFormattedScene
+from mujoco._functions import mj_printModel
+from mujoco._functions import mj_printScene
+from mujoco._functions import mj_printSchema
+from mujoco._functions import mj_projectConstraint
+from mujoco._functions import mj_ray
+from mujoco._functions import mj_rayFlex
+from mujoco._functions import mj_rayHfield
+from mujoco._functions import mj_rayMesh
+from mujoco._functions import mj_readCtrl
+from mujoco._functions import mj_readSensor
+from mujoco._functions import mj_referenceConstraint
+from mujoco._functions import mj_resetCallbacks
+from mujoco._functions import mj_resetCtrl
+from mujoco._functions import mj_resetData
+from mujoco._functions import mj_resetDataDebug
+from mujoco._functions import mj_resetDataKeyframe
+from mujoco._functions import mj_rne
+from mujoco._functions import mj_rnePostConstraint
+from mujoco._functions import mj_saveLastXML
+from mujoco._functions import mj_saveModel
+from mujoco._functions import mj_sensorAcc
+from mujoco._functions import mj_sensorPos
+from mujoco._functions import mj_sensorVel
+from mujoco._functions import mj_setCacheCapacity
+from mujoco._functions import mj_setConst
+from mujoco._functions import mj_setKeyframe
+from mujoco._functions import mj_setLengthRange
+from mujoco._functions import mj_setState
+from mujoco._functions import mj_setTotalmass
+from mujoco._functions import mj_sizeModel
+from mujoco._functions import mj_solveM
+from mujoco._functions import mj_solveM2
+from mujoco._functions import mj_stateSize
+from mujoco._functions import mj_step
+from mujoco._functions import mj_step1
+from mujoco._functions import mj_step2
+from mujoco._functions import mj_subtreeVel
+from mujoco._functions import mj_tendon
+from mujoco._functions import mj_transmission
+from mujoco._functions import mj_version
+from mujoco._functions import mj_versionString
+from mujoco._functions import mjd_inverseFD
+from mujoco._functions import mjd_quatIntegrate
+from mujoco._functions import mjd_subQuat
+from mujoco._functions import mjd_transitionFD
+from mujoco._functions import mju_Halton
+from mujoco._functions import mju_L1
+from mujoco._functions import mju_add
+from mujoco._functions import mju_add3
+from mujoco._functions import mju_addScl
+from mujoco._functions import mju_addScl3
+from mujoco._functions import mju_addTo
+from mujoco._functions import mju_addTo3
+from mujoco._functions import mju_addToScl
+from mujoco._functions import mju_addToScl3
+from mujoco._functions import mju_axisAngle2Quat
+from mujoco._functions import mju_band2Dense
+from mujoco._functions import mju_bandDiag
+from mujoco._functions import mju_bandMulMatVec
+from mujoco._functions import mju_boxQP
+from mujoco._functions import mju_cholFactor
+from mujoco._functions import mju_cholFactorBand
+from mujoco._functions import mju_cholSolve
+from mujoco._functions import mju_cholSolveBand
+from mujoco._functions import mju_cholUpdate
+from mujoco._functions import mju_clip
+from mujoco._functions import mju_copy
+from mujoco._functions import mju_copy3
+from mujoco._functions import mju_copy4
+from mujoco._functions import mju_cross
+from mujoco._functions import mju_d2n
+from mujoco._functions import mju_decodePyramid
+from mujoco._functions import mju_dense2Band
+from mujoco._functions import mju_dense2sparse
+from mujoco._functions import mju_derivQuat
+from mujoco._functions import mju_dist3
+from mujoco._functions import mju_dot
+from mujoco._functions import mju_dot3
+from mujoco._functions import mju_eig3
+from mujoco._functions import mju_encodePyramid
+from mujoco._functions import mju_euler2Quat
+from mujoco._functions import mju_eye
+from mujoco._functions import mju_f2n
+from mujoco._functions import mju_fill
+from mujoco._functions import mju_getXMLDependencies
+from mujoco._functions import mju_insertionSort
+from mujoco._functions import mju_insertionSortInt
+from mujoco._functions import mju_isBad
+from mujoco._functions import mju_isZero
+from mujoco._functions import mju_mat2Quat
+from mujoco._functions import mju_mat2Rot
+from mujoco._functions import mju_max
+from mujoco._functions import mju_min
+from mujoco._functions import mju_mulMatMat
+from mujoco._functions import mju_mulMatMatT
+from mujoco._functions import mju_mulMatTMat
+from mujoco._functions import mju_mulMatTVec
+from mujoco._functions import mju_mulMatTVec3
+from mujoco._functions import mju_mulMatVec
+from mujoco._functions import mju_mulMatVec3
+from mujoco._functions import mju_mulPose
+from mujoco._functions import mju_mulQuat
+from mujoco._functions import mju_mulQuatAxis
+from mujoco._functions import mju_mulVecMatVec
+from mujoco._functions import mju_muscleBias
+from mujoco._functions import mju_muscleDynamics
+from mujoco._functions import mju_muscleGain
+from mujoco._functions import mju_n2d
+from mujoco._functions import mju_n2f
+from mujoco._functions import mju_negPose
+from mujoco._functions import mju_negQuat
+from mujoco._functions import mju_norm
+from mujoco._functions import mju_norm3
+from mujoco._functions import mju_normalize
+from mujoco._functions import mju_normalize3
+from mujoco._functions import mju_normalize4
+from mujoco._functions import mju_printMat
+from mujoco._functions import mju_printMatSparse
+from mujoco._functions import mju_quat2Mat
+from mujoco._functions import mju_quat2Vel
+from mujoco._functions import mju_quatIntegrate
+from mujoco._functions import mju_quatZ2Vec
+from mujoco._functions import mju_rayGeom
+from mujoco._functions import mju_raySkin
+from mujoco._functions import mju_rotVecQuat
+from mujoco._functions import mju_round
+from mujoco._functions import mju_scl
+from mujoco._functions import mju_scl3
+from mujoco._functions import mju_sigmoid
+from mujoco._functions import mju_sign
+from mujoco._functions import mju_sparse2dense
+from mujoco._functions import mju_springDamper
+from mujoco._functions import mju_sqrMatTD
+from mujoco._functions import mju_standardNormal
+from mujoco._functions import mju_str2Type
+from mujoco._functions import mju_sub
+from mujoco._functions import mju_sub3
+from mujoco._functions import mju_subFrom
+from mujoco._functions import mju_subFrom3
+from mujoco._functions import mju_subQuat
+from mujoco._functions import mju_sum
+from mujoco._functions import mju_sym2dense
+from mujoco._functions import mju_symmetrize
+from mujoco._functions import mju_threadpool
+from mujoco._functions import mju_transformSpatial
+from mujoco._functions import mju_transpose
+from mujoco._functions import mju_trnVecPose
+from mujoco._functions import mju_type2Str
+from mujoco._functions import mju_unit4
+from mujoco._functions import mju_warningText
+from mujoco._functions import mju_writeLog
+from mujoco._functions import mju_writeNumBytes
+from mujoco._functions import mju_zero
+from mujoco._functions import mju_zero3
+from mujoco._functions import mju_zero4
+from mujoco._functions import mjv_addGeoms
+from mujoco._functions import mjv_alignToCamera
+from mujoco._functions import mjv_applyPerturbForce
+from mujoco._functions import mjv_applyPerturbPose
+from mujoco._functions import mjv_cameraFrame
+from mujoco._functions import mjv_cameraFrustum
+from mujoco._functions import mjv_cameraInModel
+from mujoco._functions import mjv_cameraInRoom
+from mujoco._functions import mjv_connector
+from mujoco._functions import mjv_defaultCamera
+from mujoco._functions import mjv_defaultFigure
+from mujoco._functions import mjv_defaultFreeCamera
+from mujoco._functions import mjv_defaultOption
+from mujoco._functions import mjv_defaultPerturb
+from mujoco._functions import mjv_frustumHeight
+from mujoco._functions import mjv_initGeom
+from mujoco._functions import mjv_initPerturb
+from mujoco._functions import mjv_makeLights
+from mujoco._functions import mjv_model2room
+from mujoco._functions import mjv_moveCamera
+from mujoco._functions import mjv_moveModel
+from mujoco._functions import mjv_movePerturb
+from mujoco._functions import mjv_room2model
+from mujoco._functions import mjv_select
+from mujoco._functions import mjv_updateCamera
+from mujoco._functions import mjv_updateScene
+from mujoco._functions import mjv_updateSkin
+from mujoco._render import MjrContext
+from mujoco._render import MjrRendererInfo
+from mujoco._render import mjr_addAux
+from mujoco._render import mjr_blitAux
+from mujoco._render import mjr_blitBuffer
+from mujoco._render import mjr_changeFont
+from mujoco._render import mjr_defaultRendererInfo
+from mujoco._render import mjr_drawPixels
+from mujoco._render import mjr_figure
+from mujoco._render import mjr_findRect
+from mujoco._render import mjr_finish
+from mujoco._render import mjr_getError
+from mujoco._render import mjr_getRendererInfo
+from mujoco._render import mjr_label
+from mujoco._render import mjr_maxViewport
+from mujoco._render import mjr_overlay
+from mujoco._render import mjr_readPixels
+from mujoco._render import mjr_rectangle
+from mujoco._render import mjr_render
+from mujoco._render import mjr_resizeOffscreen
+from mujoco._render import mjr_restoreBuffer
+from mujoco._render import mjr_setAux
+from mujoco._render import mjr_setBuffer
+from mujoco._render import mjr_text
+from mujoco._render import mjr_uploadHField
+from mujoco._render import mjr_uploadMesh
+from mujoco._render import mjr_uploadTexture
+from mujoco._specs import MjByteVec
+from mujoco._specs import MjCharVec
+from mujoco._specs import MjDoubleVec
+from mujoco._specs import MjFloatVec
+from mujoco._specs import MjIntVec
+from mujoco._specs import MjSpec
+from mujoco._specs import MjStringVec
+from mujoco._specs import MjVfs
+from mujoco._specs import MjVisualHeadlight
+from mujoco._specs import MjVisualRgba
+from mujoco._specs import MjsActuator
+from mujoco._specs import MjsAuthored
+from mujoco._specs import MjsBody
+from mujoco._specs import MjsCamera
+from mujoco._specs import MjsCompiler
+from mujoco._specs import MjsDefault
+from mujoco._specs import MjsElement
+from mujoco._specs import MjsEquality
+from mujoco._specs import MjsExclude
+from mujoco._specs import MjsFlex
+from mujoco._specs import MjsFrame
+from mujoco._specs import MjsGeom
+from mujoco._specs import MjsHField
+from mujoco._specs import MjsJoint
+from mujoco._specs import MjsKey
+from mujoco._specs import MjsLight
+from mujoco._specs import MjsMaterial
+from mujoco._specs import MjsMesh
+from mujoco._specs import MjsNumeric
+from mujoco._specs import MjsOrientation
+from mujoco._specs import MjsPair
+from mujoco._specs import MjsPlugin
+from mujoco._specs import MjsSensor
+from mujoco._specs import MjsSite
+from mujoco._specs import MjsSkin
+from mujoco._specs import MjsTendon
+from mujoco._specs import MjsTendonPath
+from mujoco._specs import MjsText
+from mujoco._specs import MjsTexture
+from mujoco._specs import MjsTuple
+from mujoco._specs import MjsWrap
+from mujoco._structs import MjContact
+from mujoco._structs import MjData
+from mujoco._structs import MjLROpt
+from mujoco._structs import MjLogConfig
+from mujoco._structs import MjLogMessage
+from mujoco._structs import MjModel
+from mujoco._structs import MjOption
+from mujoco._structs import MjPreContact
+from mujoco._structs import MjSolverStat
+from mujoco._structs import MjStatistic
+from mujoco._structs import MjTimerStat
+from mujoco._structs import MjVisual
+from mujoco._structs import MjWarningStat
+from mujoco._structs import MjrRect
+from mujoco._structs import MjrVertexAttribute
+from mujoco._structs import MjvCamera
+from mujoco._structs import MjvFigure
+from mujoco._structs import MjvGLCamera
+from mujoco._structs import MjvGeom
+from mujoco._structs import MjvLight
+from mujoco._structs import MjvOption
+from mujoco._structs import MjvPerturb
+from mujoco._structs import MjvScene
+from mujoco._structs import mjv_averageCamera
+from mujoco.rendering.classic.renderer import Renderer
+import numpy as np
+from numpy import float64 as MJTNUM_DTYPE
+import os as os
+import platform as platform
+import subprocess as subprocess
+import typing
+from typing import Any
+from typing import IO
+import warnings as warnings
+import zipfile as zipfile
+from . import _callbacks
+from . import _constants
+from . import _enums
+from . import _errors
+from . import _functions
+from . import _render
+from . import _specs
+from . import _structs
+from . import rendering
+__all__: list[str] = ['Any', 'FatalError', 'HEADERS_DIR', 'IO', 'MJTNUM_BYTES', 'MJTNUM_DTYPE', 'MjByteVec', 'MjCharVec', 'MjContact', 'MjData', 'MjDoubleVec', 'MjFloatVec', 'MjIntVec', 'MjLROpt', 'MjLogConfig', 'MjLogMessage', 'MjModel', 'MjOption', 'MjPreContact', 'MjSolverStat', 'MjSpec', 'MjStatistic', 'MjStringVec', 'MjStruct', 'MjTimerStat', 'MjVfs', 'MjVisual', 'MjVisualHeadlight', 'MjVisualRgba', 'MjWarningStat', 'MjrContext', 'MjrRect', 'MjrRendererInfo', 'MjrVertexAttribute', 'MjsActuator', 'MjsAuthored', 'MjsBody', 'MjsCamera', 'MjsCompiler', 'MjsDefault', 'MjsElement', 'MjsEquality', 'MjsExclude', 'MjsFlex', 'MjsFrame', 'MjsGeom', 'MjsHField', 'MjsJoint', 'MjsKey', 'MjsLight', 'MjsMaterial', 'MjsMesh', 'MjsNumeric', 'MjsOrientation', 'MjsPair', 'MjsPlugin', 'MjsSensor', 'MjsSite', 'MjsSkin', 'MjsTendon', 'MjsTendonPath', 'MjsText', 'MjsTexture', 'MjsTuple', 'MjsWrap', 'MjvCamera', 'MjvFigure', 'MjvGLCamera', 'MjvGeom', 'MjvLight', 'MjvOption', 'MjvPerturb', 'MjvScene', 'PLUGINS_DIR', 'PLUGIN_HANDLES', 'Renderer', 'UnexpectedError', 'ctypes', 'from_zip', 'get_mjcb_act_bias', 'get_mjcb_act_dyn', 'get_mjcb_act_gain', 'get_mjcb_contactfilter', 'get_mjcb_control', 'get_mjcb_passive', 'get_mjcb_sensor', 'get_mjcb_time', 'get_mju_user_free', 'get_mju_user_malloc', 'get_mju_user_warning', 'mjDISABLESTRING', 'mjENABLESTRING', 'mjFRAMESTRING', 'mjLABELSTRING', 'mjMAXCONPAIR', 'mjMAXFLEXNODES', 'mjMAXIMP', 'mjMAXLIGHT', 'mjMAXLINE', 'mjMAXLINEPNT', 'mjMAXOVERLAY', 'mjMAXPLANEGRID', 'mjMAXTREEDEPTH', 'mjMAXVAL', 'mjMINAWAKE', 'mjMINIMP', 'mjMINMU', 'mjMINVAL', 'mjNBIAS', 'mjNDYN', 'mjNEQDATA', 'mjNFLUID', 'mjNGAIN', 'mjNGROUP', 'mjNIMP', 'mjNISLAND', 'mjNPOLY', 'mjNREF', 'mjNSENS', 'mjNSOLVER', 'mjPI', 'mjRNDSTRING', 'mjTIMERSTRING', 'mjVERSION_HEADER', 'mjVISSTRING', 'mj_Euler', 'mj_RungeKutta', 'mj_actuatorInputName', 'mj_addContact', 'mj_addM', 'mj_angmomMat', 'mj_applyFT', 'mj_camlight', 'mj_checkAcc', 'mj_checkPos', 'mj_checkVel', 'mj_clearCache', 'mj_collision', 'mj_comPos', 'mj_comVel', 'mj_compareFwdInv', 'mj_constraintUpdate', 'mj_contactForce', 'mj_copyData', 'mj_copyState', 'mj_crb', 'mj_defaultLROpt', 'mj_defaultOption', 'mj_defaultSolRefImp', 'mj_defaultVisual', 'mj_differentiatePos', 'mj_energyPos', 'mj_energyVel', 'mj_extractState', 'mj_factorM', 'mj_flex', 'mj_forward', 'mj_forwardSkip', 'mj_fullM', 'mj_fwdAcceleration', 'mj_fwdActuation', 'mj_fwdConstraint', 'mj_fwdKinematics', 'mj_fwdPosition', 'mj_fwdVelocity', 'mj_geomDistance', 'mj_getCache', 'mj_getCacheCapacity', 'mj_getCacheSize', 'mj_getState', 'mj_getTotalmass', 'mj_id2name', 'mj_implicit', 'mj_initCtrlHistory', 'mj_initSensorHistory', 'mj_integratePos', 'mj_invConstraint', 'mj_invPosition', 'mj_invVelocity', 'mj_inverse', 'mj_inverseSkip', 'mj_isDual', 'mj_isPyramidal', 'mj_isSparse', 'mj_island', 'mj_jac', 'mj_jacBody', 'mj_jacBodyCom', 'mj_jacDot', 'mj_jacGeom', 'mj_jacPointAxis', 'mj_jacSite', 'mj_jacSubtreeCom', 'mj_kinematics', 'mj_loadAllPluginLibraries', 'mj_loadPluginLibrary', 'mj_local2Global', 'mj_makeConstraint', 'mj_makeM', 'mj_maxContact', 'mj_mulJacTVec', 'mj_mulJacVec', 'mj_mulM', 'mj_mulM2', 'mj_multiRay', 'mj_name2id', 'mj_normalizeQuat', 'mj_objectAcceleration', 'mj_objectVelocity', 'mj_passive', 'mj_printData', 'mj_printFormattedData', 'mj_printFormattedModel', 'mj_printFormattedScene', 'mj_printModel', 'mj_printScene', 'mj_printSchema', 'mj_projectConstraint', 'mj_ray', 'mj_rayFlex', 'mj_rayHfield', 'mj_rayMesh', 'mj_readCtrl', 'mj_readSensor', 'mj_referenceConstraint', 'mj_resetCallbacks', 'mj_resetCtrl', 'mj_resetData', 'mj_resetDataDebug', 'mj_resetDataKeyframe', 'mj_rne', 'mj_rnePostConstraint', 'mj_saveLastXML', 'mj_saveModel', 'mj_sensorAcc', 'mj_sensorPos', 'mj_sensorVel', 'mj_setCacheCapacity', 'mj_setConst', 'mj_setKeyframe', 'mj_setLengthRange', 'mj_setState', 'mj_setTotalmass', 'mj_sizeModel', 'mj_solveM', 'mj_solveM2', 'mj_stateSize', 'mj_step', 'mj_step1', 'mj_step2', 'mj_subtreeVel', 'mj_tendon', 'mj_transmission', 'mj_version', 'mj_versionString', 'mjd_inverseFD', 'mjd_quatIntegrate', 'mjd_subQuat', 'mjd_transitionFD', 'mjrIndexType', 'mjrMeshPrimitiveType', 'mjrPixelFormat', 'mjrVertexAttributeType', 'mjrVertexAttributeUsage', 'mjr_addAux', 'mjr_blitAux', 'mjr_blitBuffer', 'mjr_changeFont', 'mjr_defaultRendererInfo', 'mjr_drawPixels', 'mjr_figure', 'mjr_findRect', 'mjr_finish', 'mjr_getError', 'mjr_getRendererInfo', 'mjr_label', 'mjr_maxViewport', 'mjr_overlay', 'mjr_readPixels', 'mjr_rectangle', 'mjr_render', 'mjr_resizeOffscreen', 'mjr_restoreBuffer', 'mjr_setAux', 'mjr_setBuffer', 'mjr_text', 'mjr_uploadHField', 'mjr_uploadMesh', 'mjr_uploadTexture', 'mjtAlignFree', 'mjtBias', 'mjtBuiltin', 'mjtButton', 'mjtCTimer', 'mjtCamLight', 'mjtCamOutBit', 'mjtCamera', 'mjtCatBit', 'mjtColorSpace', 'mjtConDataField', 'mjtCone', 'mjtConflict', 'mjtConstraint', 'mjtConstraintState', 'mjtCtrlChart', 'mjtDataType', 'mjtDepthMap', 'mjtDisableBit', 'mjtDyn', 'mjtEnableBit', 'mjtEq', 'mjtEvent', 'mjtFlexSelf', 'mjtFont', 'mjtFontScale', 'mjtFrame', 'mjtFramebuffer', 'mjtGain', 'mjtGeom', 'mjtGeomInertia', 'mjtGridPos', 'mjtInertiaFromGeom', 'mjtIntegrator', 'mjtItem', 'mjtJacobian', 'mjtJoint', 'mjtLRMode', 'mjtLabel', 'mjtLightType', 'mjtLimited', 'mjtLogLevel', 'mjtLogTopic', 'mjtMark', 'mjtMeshBuiltin', 'mjtMeshInertia', 'mjtMouse', 'mjtObj', 'mjtOrientation', 'mjtPertBit', 'mjtPluginCapabilityBit', 'mjtProjection', 'mjtRayDataField', 'mjtRndFlag', 'mjtSDFType', 'mjtSameFrame', 'mjtSection', 'mjtSensor', 'mjtSleepPolicy', 'mjtSleepState', 'mjtSolver', 'mjtStage', 'mjtState', 'mjtStereo', 'mjtTexture', 'mjtTextureRole', 'mjtTimer', 'mjtTrn', 'mjtVisFlag', 'mjtWarning', 'mjtWrap', 'mju_Halton', 'mju_L1', 'mju_add', 'mju_add3', 'mju_addScl', 'mju_addScl3', 'mju_addTo', 'mju_addTo3', 'mju_addToScl', 'mju_addToScl3', 'mju_axisAngle2Quat', 'mju_band2Dense', 'mju_bandDiag', 'mju_bandMulMatVec', 'mju_boxQP', 'mju_cholFactor', 'mju_cholFactorBand', 'mju_cholSolve', 'mju_cholSolveBand', 'mju_cholUpdate', 'mju_clip', 'mju_copy', 'mju_copy3', 'mju_copy4', 'mju_cross', 'mju_d2n', 'mju_decodePyramid', 'mju_dense2Band', 'mju_dense2sparse', 'mju_derivQuat', 'mju_dist3', 'mju_dot', 'mju_dot3', 'mju_eig3', 'mju_encodePyramid', 'mju_euler2Quat', 'mju_eye', 'mju_f2n', 'mju_fill', 'mju_getXMLDependencies', 'mju_insertionSort', 'mju_insertionSortInt', 'mju_isBad', 'mju_isZero', 'mju_mat2Quat', 'mju_mat2Rot', 'mju_max', 'mju_min', 'mju_mulMatMat', 'mju_mulMatMatT', 'mju_mulMatTMat', 'mju_mulMatTVec', 'mju_mulMatTVec3', 'mju_mulMatVec', 'mju_mulMatVec3', 'mju_mulPose', 'mju_mulQuat', 'mju_mulQuatAxis', 'mju_mulVecMatVec', 'mju_muscleBias', 'mju_muscleDynamics', 'mju_muscleGain', 'mju_n2d', 'mju_n2f', 'mju_negPose', 'mju_negQuat', 'mju_norm', 'mju_norm3', 'mju_normalize', 'mju_normalize3', 'mju_normalize4', 'mju_printMat', 'mju_printMatSparse', 'mju_quat2Mat', 'mju_quat2Vel', 'mju_quatIntegrate', 'mju_quatZ2Vec', 'mju_rayGeom', 'mju_raySkin', 'mju_rotVecQuat', 'mju_round', 'mju_scl', 'mju_scl3', 'mju_sigmoid', 'mju_sign', 'mju_sparse2dense', 'mju_springDamper', 'mju_sqrMatTD', 'mju_standardNormal', 'mju_str2Type', 'mju_sub', 'mju_sub3', 'mju_subFrom', 'mju_subFrom3', 'mju_subQuat', 'mju_sum', 'mju_sym2dense', 'mju_symmetrize', 'mju_threadpool', 'mju_transformSpatial', 'mju_transpose', 'mju_trnVecPose', 'mju_type2Str', 'mju_unit4', 'mju_warningText', 'mju_writeLog', 'mju_writeNumBytes', 'mju_zero', 'mju_zero3', 'mju_zero4', 'mjv_addGeoms', 'mjv_alignToCamera', 'mjv_applyPerturbForce', 'mjv_applyPerturbPose', 'mjv_averageCamera', 'mjv_cameraFrame', 'mjv_cameraFrustum', 'mjv_cameraInModel', 'mjv_cameraInRoom', 'mjv_connector', 'mjv_defaultCamera', 'mjv_defaultFigure', 'mjv_defaultFreeCamera', 'mjv_defaultOption', 'mjv_defaultPerturb', 'mjv_frustumHeight', 'mjv_initGeom', 'mjv_initPerturb', 'mjv_makeLights', 'mjv_model2room', 'mjv_moveCamera', 'mjv_moveModel', 'mjv_movePerturb', 'mjv_room2model', 'mjv_select', 'mjv_updateCamera', 'mjv_updateScene', 'mjv_updateSkin', 'np', 'os', 'platform', 'rendering', 'set_mjcb_act_bias', 'set_mjcb_act_dyn', 'set_mjcb_act_gain', 'set_mjcb_contactfilter', 'set_mjcb_control', 'set_mjcb_passive', 'set_mjcb_sensor', 'set_mjcb_time', 'set_mju_user_free', 'set_mju_user_malloc', 'set_mju_user_warning', 'subprocess', 'to_zip', 'warnings', 'zipfile']
+class FatalError(Exception):
+    pass
+class UnexpectedError(Exception):
+    pass
+class _MjBindData:
+    """
+    Wrapper for MjData that allows binding multiple specs.
+    """
+    def __getattr__(self, key: str):
+        ...
+    def __init__(self, elements: typing.Sequence[typing.Any]):
+        ...
+    def __setattr__(self, key: str, value: typing.Any):
+        ...
+class _MjBindModel:
+    """
+    Wrapper for MjModel that allows binding multiple specs.
+    """
+    def __getattr__(self, key: str):
+        ...
+    def __init__(self, elements: typing.Sequence[typing.Any]):
+        ...
+    def __setattr__(self, key: str, value: typing.Any):
+        ...
+def _bind_data(data: _structs.MjData, specs: typing.Union[typing.Sequence[typing.Union[mujoco._specs.MjsBody, mujoco._specs.MjsFrame, mujoco._specs.MjsGeom, mujoco._specs.MjsJoint, mujoco._specs.MjsLight, mujoco._specs.MjsMaterial, mujoco._specs.MjsSite, mujoco._specs.MjsMesh, mujoco._specs.MjsSkin, mujoco._specs.MjsTexture, mujoco._specs.MjsText, mujoco._specs.MjsTuple, mujoco._specs.MjsCamera, mujoco._specs.MjsFlex, mujoco._specs.MjsHField, mujoco._specs.MjsKey, mujoco._specs.MjsNumeric, mujoco._specs.MjsPair, mujoco._specs.MjsExclude, mujoco._specs.MjsEquality, mujoco._specs.MjsTendon, mujoco._specs.MjsSensor, mujoco._specs.MjsActuator, mujoco._specs.MjsPlugin]], mujoco._specs.MjsBody, mujoco._specs.MjsFrame, mujoco._specs.MjsGeom, mujoco._specs.MjsJoint, mujoco._specs.MjsLight, mujoco._specs.MjsMaterial, mujoco._specs.MjsSite, mujoco._specs.MjsMesh, mujoco._specs.MjsSkin, mujoco._specs.MjsTexture, mujoco._specs.MjsText, mujoco._specs.MjsTuple, mujoco._specs.MjsCamera, mujoco._specs.MjsFlex, mujoco._specs.MjsHField, mujoco._specs.MjsKey, mujoco._specs.MjsNumeric, mujoco._specs.MjsPair, mujoco._specs.MjsExclude, mujoco._specs.MjsEquality, mujoco._specs.MjsTendon, mujoco._specs.MjsSensor, mujoco._specs.MjsActuator, mujoco._specs.MjsPlugin]):
+    """
+    Bind a Mujoco spec to a mjData.
+    
+    Args:
+      data: The mjData to bind to.
+      specs: The mjSpec elements to use for binding, can be a single element or a
+        sequence.
+    Returns:
+      A MjDataGroupedViews object or a list of the same type.
+    """
+def _bind_model(model: _structs.MjModel, specs: typing.Union[typing.Sequence[typing.Union[mujoco._specs.MjsBody, mujoco._specs.MjsFrame, mujoco._specs.MjsGeom, mujoco._specs.MjsJoint, mujoco._specs.MjsLight, mujoco._specs.MjsMaterial, mujoco._specs.MjsSite, mujoco._specs.MjsMesh, mujoco._specs.MjsSkin, mujoco._specs.MjsTexture, mujoco._specs.MjsText, mujoco._specs.MjsTuple, mujoco._specs.MjsCamera, mujoco._specs.MjsFlex, mujoco._specs.MjsHField, mujoco._specs.MjsKey, mujoco._specs.MjsNumeric, mujoco._specs.MjsPair, mujoco._specs.MjsExclude, mujoco._specs.MjsEquality, mujoco._specs.MjsTendon, mujoco._specs.MjsSensor, mujoco._specs.MjsActuator, mujoco._specs.MjsPlugin]], mujoco._specs.MjsBody, mujoco._specs.MjsFrame, mujoco._specs.MjsGeom, mujoco._specs.MjsJoint, mujoco._specs.MjsLight, mujoco._specs.MjsMaterial, mujoco._specs.MjsSite, mujoco._specs.MjsMesh, mujoco._specs.MjsSkin, mujoco._specs.MjsTexture, mujoco._specs.MjsText, mujoco._specs.MjsTuple, mujoco._specs.MjsCamera, mujoco._specs.MjsFlex, mujoco._specs.MjsHField, mujoco._specs.MjsKey, mujoco._specs.MjsNumeric, mujoco._specs.MjsPair, mujoco._specs.MjsExclude, mujoco._specs.MjsEquality, mujoco._specs.MjsTendon, mujoco._specs.MjsSensor, mujoco._specs.MjsActuator, mujoco._specs.MjsPlugin]):
+    """
+    Bind a Mujoco spec to a mjModel.
+    
+    Args:
+      model: The mjModel to bind to.
+      specs: The mjSpec elements to use for binding, can be a single element or a
+        sequence.
+    Returns:
+      A MjModelGroupedViews object or a list of the same type.
+    """
+def _load_all_bundled_plugins():
+    ...
+def from_zip(file: typing.Union[str, typing.IO[bytes]]) -> _specs.MjSpec:
+    """
+    Reads a zip file and returns an MjSpec.
+    
+    Args:
+      file: The path to the file to read from or the file object to read from.
+    Returns:
+      An MjSpec object.
+    """
+def to_zip(spec: _specs.MjSpec, file: typing.Union[str, typing.IO[bytes]]) -> None:
+    """
+    Converts an MjSpec to a zip file.
+    
+    Args:
+      spec: The mjSpec to save to a file.
+      file: The path to the file to save to or the file object to write to.
+    """
+HEADERS_DIR: str
+MJTNUM_BYTES: int = 8
+MjStruct: typing._UnionGenericAlias  # value = typing.Union[mujoco._specs.MjsBody, mujoco._specs.MjsFrame, mujoco._specs.MjsGeom, mujoco._specs.MjsJoint, mujoco._specs.MjsLight, mujoco._specs.MjsMaterial, mujoco._specs.MjsSite, mujoco._specs.MjsMesh, mujoco._specs.MjsSkin, mujoco._specs.MjsTexture, mujoco._specs.MjsText, mujoco._specs.MjsTuple, mujoco._specs.MjsCamera, mujoco._specs.MjsFlex, mujoco._specs.MjsHField, mujoco._specs.MjsKey, mujoco._specs.MjsNumeric, mujoco._specs.MjsPair, mujoco._specs.MjsExclude, mujoco._specs.MjsEquality, mujoco._specs.MjsTendon, mujoco._specs.MjsSensor, mujoco._specs.MjsActuator, mujoco._specs.MjsPlugin]
+PLUGINS_DIR: str
+PLUGIN_HANDLES: list
+_SYSTEM: str
+__version__: str = '3.11.0'
+mjDISABLESTRING: tuple = ('Constraint', 'Equality', 'Frictionloss', 'Limit', 'Contact', 'Spring', 'Damper', 'Gravity', 'Clampctrl', 'Warmstart', 'Filterparent', 'Actuation', 'Refsafe', 'Sensor', 'Midphase', 'Eulerdamp', 'AutoReset', 'NativeCCD', 'Island', 'MultiCCD')
+mjENABLESTRING: tuple = ('Override', 'Energy', 'Fwdinv', 'InvDiscrete', 'Sleep', 'DiagExact')
+mjFRAMESTRING: tuple = ('None', 'Body', 'Geom', 'Site', 'Camera', 'Light', 'Contact', 'World')
+mjLABELSTRING: tuple = ('None', 'Body', 'Joint', 'Geom', 'Site', 'Camera', 'Light', 'Tendon', 'Actuator', 'Constraint', 'Flex', 'Skin', 'Selection', 'SelPoint', 'Contact', 'ContactForce', 'Island')
+mjMAXCONPAIR: int = 50
+mjMAXFLEXNODES: int = 27
+mjMAXIMP: float = 0.9999
+mjMAXLIGHT: int = 100
+mjMAXLINE: int = 100
+mjMAXLINEPNT: int = 1001
+mjMAXOVERLAY: int = 500
+mjMAXPLANEGRID: int = 200
+mjMAXTREEDEPTH: int = 50
+mjMAXVAL: float = 10000000000.0
+mjMINAWAKE: int = 10
+mjMINIMP: float = 0.0001
+mjMINMU: float = 1e-05
+mjMINVAL: float = 1e-15
+mjNBIAS: int = 10
+mjNDYN: int = 10
+mjNEQDATA: int = 11
+mjNFLUID: int = 12
+mjNGAIN: int = 10
+mjNGROUP: int = 6
+mjNIMP: int = 5
+mjNISLAND: int = 20
+mjNPOLY: int = 2
+mjNREF: int = 2
+mjNSENS: int = 3
+mjNSOLVER: int = 200
+mjPI: float = 3.141592653589793
+mjRNDSTRING: tuple = (('Shadow', '1', 'S'), ('Wireframe', '0', 'W'), ('Reflection', '1', 'R'), ('Additive', '0', 'L'), ('Skybox', '1', 'K'), ('Fog', '0', 'G'), ('Haze', '1', '/'), ('Depth', '0', ''), ('Segment', '0', ','), ('Id Color', '0', ''), ('Cull Face', '1', ''))
+mjTIMERSTRING: tuple = ('step', 'forward', 'inverse', 'position', 'velocity', 'actuation', 'constraint', 'advance', 'pos_kinematics', 'pos_inertia', 'pos_collision', 'pos_make', 'pos_project', 'col_broadphase', 'col_narrowphase')
+mjVERSION_HEADER: int = 3011000
+mjVISSTRING: tuple = (('Convex Hull', '0', 'H'), ('Texture', '1', 'X'), ('Joint', '0', 'J'), ('Camera', '0', 'Q'), ('Actuator', '0', 'U'), ('Activation', '0', ','), ('Light', '0', 'Z'), ('Tendon', '1', 'V'), ('Range Finder', '1', 'Y'), ('Equality', '0', 'E'), ('Inertia', '0', 'I'), ('Scale Inertia', '0', "'"), ('Perturb Force', '0', 'B'), ('Perturb Object', '1', 'O'), ('Contact Point', '0', 'C'), ('Island', '0', 'N'), ('Contact Force', '0', 'F'), ('Contact Split', '0', 'P'), ('Transparent', '0', 'T'), ('Auto Connect', '0', 'A'), ('Center of Mass', '0', 'M'), ('Select Point', '0', ''), ('Static Body', '1', 'D'), ('Skin', '1', ';'), ('Flex Vert', '0', ''), ('Flex Edge', '1', ''), ('Flex Face', '0', ''), ('Flex Skin', '1', ''), ('Body Tree', '0', '`'), ('Mesh Tree', '0', '\\'), ('SDF iters', '0', ''))
diff --git a/typings/mujoco/_callbacks.pyi b/typings/mujoco/_callbacks.pyi
new file mode 100644
index 0000000..99e31c7
--- /dev/null
+++ b/typings/mujoco/_callbacks.pyi
@@ -0,0 +1,47 @@
+from __future__ import annotations
+import typing
+__all__: list[str] = ['get_mjcb_act_bias', 'get_mjcb_act_dyn', 'get_mjcb_act_gain', 'get_mjcb_contactfilter', 'get_mjcb_control', 'get_mjcb_passive', 'get_mjcb_sensor', 'get_mjcb_time', 'get_mju_user_free', 'get_mju_user_malloc', 'get_mju_user_warning', 'set_mjcb_act_bias', 'set_mjcb_act_dyn', 'set_mjcb_act_gain', 'set_mjcb_contactfilter', 'set_mjcb_control', 'set_mjcb_passive', 'set_mjcb_sensor', 'set_mjcb_time', 'set_mju_user_free', 'set_mju_user_malloc', 'set_mju_user_warning']
+def get_mjcb_act_bias() -> typing.Any:
+    ...
+def get_mjcb_act_dyn() -> typing.Any:
+    ...
+def get_mjcb_act_gain() -> typing.Any:
+    ...
+def get_mjcb_contactfilter() -> typing.Any:
+    ...
+def get_mjcb_control() -> typing.Any:
+    ...
+def get_mjcb_passive() -> typing.Any:
+    ...
+def get_mjcb_sensor() -> typing.Any:
+    ...
+def get_mjcb_time() -> typing.Any:
+    ...
+def get_mju_user_free() -> typing.Any:
+    ...
+def get_mju_user_malloc() -> typing.Any:
+    ...
+def get_mju_user_warning() -> typing.Any:
+    ...
+def set_mjcb_act_bias(arg0: typing.Any) -> None:
+    ...
+def set_mjcb_act_dyn(arg0: typing.Any) -> None:
+    ...
+def set_mjcb_act_gain(arg0: typing.Any) -> None:
+    ...
+def set_mjcb_contactfilter(arg0: typing.Any) -> None:
+    ...
+def set_mjcb_control(arg0: typing.Any) -> None:
+    ...
+def set_mjcb_passive(arg0: typing.Any) -> None:
+    ...
+def set_mjcb_sensor(arg0: typing.Any) -> None:
+    ...
+def set_mjcb_time(arg0: typing.Any) -> None:
+    ...
+def set_mju_user_free(arg0: typing.Any) -> None:
+    ...
+def set_mju_user_malloc(arg0: typing.Any) -> None:
+    ...
+def set_mju_user_warning(arg0: typing.Any) -> None:
+    ...
diff --git a/typings/mujoco/_constants.pyi b/typings/mujoco/_constants.pyi
new file mode 100644
index 0000000..f9bfe0c
--- /dev/null
+++ b/typings/mujoco/_constants.pyi
@@ -0,0 +1,38 @@
+from __future__ import annotations
+__all__: list[str] = ['MJTNUM_BYTES', 'mjDISABLESTRING', 'mjENABLESTRING', 'mjFRAMESTRING', 'mjLABELSTRING', 'mjMAXCONPAIR', 'mjMAXFLEXNODES', 'mjMAXIMP', 'mjMAXLIGHT', 'mjMAXLINE', 'mjMAXLINEPNT', 'mjMAXOVERLAY', 'mjMAXPLANEGRID', 'mjMAXTREEDEPTH', 'mjMAXVAL', 'mjMINAWAKE', 'mjMINIMP', 'mjMINMU', 'mjMINVAL', 'mjNBIAS', 'mjNDYN', 'mjNEQDATA', 'mjNFLUID', 'mjNGAIN', 'mjNGROUP', 'mjNIMP', 'mjNISLAND', 'mjNPOLY', 'mjNREF', 'mjNSENS', 'mjNSOLVER', 'mjPI', 'mjRNDSTRING', 'mjTIMERSTRING', 'mjVERSION_HEADER', 'mjVISSTRING']
+MJTNUM_BYTES: int = 8
+mjDISABLESTRING: tuple = ('Constraint', 'Equality', 'Frictionloss', 'Limit', 'Contact', 'Spring', 'Damper', 'Gravity', 'Clampctrl', 'Warmstart', 'Filterparent', 'Actuation', 'Refsafe', 'Sensor', 'Midphase', 'Eulerdamp', 'AutoReset', 'NativeCCD', 'Island', 'MultiCCD')
+mjENABLESTRING: tuple = ('Override', 'Energy', 'Fwdinv', 'InvDiscrete', 'Sleep', 'DiagExact')
+mjFRAMESTRING: tuple = ('None', 'Body', 'Geom', 'Site', 'Camera', 'Light', 'Contact', 'World')
+mjLABELSTRING: tuple = ('None', 'Body', 'Joint', 'Geom', 'Site', 'Camera', 'Light', 'Tendon', 'Actuator', 'Constraint', 'Flex', 'Skin', 'Selection', 'SelPoint', 'Contact', 'ContactForce', 'Island')
+mjMAXCONPAIR: int = 50
+mjMAXFLEXNODES: int = 27
+mjMAXIMP: float = 0.9999
+mjMAXLIGHT: int = 100
+mjMAXLINE: int = 100
+mjMAXLINEPNT: int = 1001
+mjMAXOVERLAY: int = 500
+mjMAXPLANEGRID: int = 200
+mjMAXTREEDEPTH: int = 50
+mjMAXVAL: float = 10000000000.0
+mjMINAWAKE: int = 10
+mjMINIMP: float = 0.0001
+mjMINMU: float = 1e-05
+mjMINVAL: float = 1e-15
+mjNBIAS: int = 10
+mjNDYN: int = 10
+mjNEQDATA: int = 11
+mjNFLUID: int = 12
+mjNGAIN: int = 10
+mjNGROUP: int = 6
+mjNIMP: int = 5
+mjNISLAND: int = 20
+mjNPOLY: int = 2
+mjNREF: int = 2
+mjNSENS: int = 3
+mjNSOLVER: int = 200
+mjPI: float = 3.141592653589793
+mjRNDSTRING: tuple = (('Shadow', '1', 'S'), ('Wireframe', '0', 'W'), ('Reflection', '1', 'R'), ('Additive', '0', 'L'), ('Skybox', '1', 'K'), ('Fog', '0', 'G'), ('Haze', '1', '/'), ('Depth', '0', ''), ('Segment', '0', ','), ('Id Color', '0', ''), ('Cull Face', '1', ''))
+mjTIMERSTRING: tuple = ('step', 'forward', 'inverse', 'position', 'velocity', 'actuation', 'constraint', 'advance', 'pos_kinematics', 'pos_inertia', 'pos_collision', 'pos_make', 'pos_project', 'col_broadphase', 'col_narrowphase')
+mjVERSION_HEADER: int = 3011000
+mjVISSTRING: tuple = (('Convex Hull', '0', 'H'), ('Texture', '1', 'X'), ('Joint', '0', 'J'), ('Camera', '0', 'Q'), ('Actuator', '0', 'U'), ('Activation', '0', ','), ('Light', '0', 'Z'), ('Tendon', '1', 'V'), ('Range Finder', '1', 'Y'), ('Equality', '0', 'E'), ('Inertia', '0', 'I'), ('Scale Inertia', '0', "'"), ('Perturb Force', '0', 'B'), ('Perturb Object', '1', 'O'), ('Contact Point', '0', 'C'), ('Island', '0', 'N'), ('Contact Force', '0', 'F'), ('Contact Split', '0', 'P'), ('Transparent', '0', 'T'), ('Auto Connect', '0', 'A'), ('Center of Mass', '0', 'M'), ('Select Point', '0', ''), ('Static Body', '1', 'D'), ('Skin', '1', ';'), ('Flex Vert', '0', ''), ('Flex Edge', '1', ''), ('Flex Face', '0', ''), ('Flex Skin', '1', ''), ('Body Tree', '0', '`'), ('Mesh Tree', '0', '\\'), ('SDF iters', '0', ''))
diff --git a/typings/mujoco/_enums.pyi b/typings/mujoco/_enums.pyi
new file mode 100644
index 0000000..11feeb6
--- /dev/null
+++ b/typings/mujoco/_enums.pyi
@@ -0,0 +1,10563 @@
+from __future__ import annotations
+import typing
+__all__: list[str] = ['mjrIndexType', 'mjrMeshPrimitiveType', 'mjrPixelFormat', 'mjrVertexAttributeType', 'mjrVertexAttributeUsage', 'mjtAlignFree', 'mjtBias', 'mjtBuiltin', 'mjtButton', 'mjtCTimer', 'mjtCamLight', 'mjtCamOutBit', 'mjtCamera', 'mjtCatBit', 'mjtColorSpace', 'mjtConDataField', 'mjtCone', 'mjtConflict', 'mjtConstraint', 'mjtConstraintState', 'mjtCtrlChart', 'mjtDataType', 'mjtDepthMap', 'mjtDisableBit', 'mjtDyn', 'mjtEnableBit', 'mjtEq', 'mjtEvent', 'mjtFlexSelf', 'mjtFont', 'mjtFontScale', 'mjtFrame', 'mjtFramebuffer', 'mjtGain', 'mjtGeom', 'mjtGeomInertia', 'mjtGridPos', 'mjtInertiaFromGeom', 'mjtIntegrator', 'mjtItem', 'mjtJacobian', 'mjtJoint', 'mjtLRMode', 'mjtLabel', 'mjtLightType', 'mjtLimited', 'mjtLogLevel', 'mjtLogTopic', 'mjtMark', 'mjtMeshBuiltin', 'mjtMeshInertia', 'mjtMouse', 'mjtObj', 'mjtOrientation', 'mjtPertBit', 'mjtPluginCapabilityBit', 'mjtProjection', 'mjtRayDataField', 'mjtRndFlag', 'mjtSDFType', 'mjtSameFrame', 'mjtSection', 'mjtSensor', 'mjtSleepPolicy', 'mjtSleepState', 'mjtSolver', 'mjtStage', 'mjtState', 'mjtStereo', 'mjtTexture', 'mjtTextureRole', 'mjtTimer', 'mjtTrn', 'mjtVisFlag', 'mjtWarning', 'mjtWrap']
+class mjrIndexType:
+    """
+    Members:
+    
+      mjINDEX_TYPE_U16
+    
+      mjINDEX_TYPE_U32
+    """
+    __members__: typing.ClassVar[dict[str, mjrIndexType]]  # value = {'mjINDEX_TYPE_U16': <mjrIndexType.mjINDEX_TYPE_U16: 0>, 'mjINDEX_TYPE_U32': <mjrIndexType.mjINDEX_TYPE_U32: 1>}
+    mjINDEX_TYPE_U16: typing.ClassVar[mjrIndexType]  # value = <mjrIndexType.mjINDEX_TYPE_U16: 0>
+    mjINDEX_TYPE_U32: typing.ClassVar[mjrIndexType]  # value = <mjrIndexType.mjINDEX_TYPE_U32: 1>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjrMeshPrimitiveType:
+    """
+    Members:
+    
+      mjMESH_PRIMITIVE_TYPE_TRIANGLES
+    
+      mjMESH_PRIMITIVE_TYPE_LINES
+    """
+    __members__: typing.ClassVar[dict[str, mjrMeshPrimitiveType]]  # value = {'mjMESH_PRIMITIVE_TYPE_TRIANGLES': <mjrMeshPrimitiveType.mjMESH_PRIMITIVE_TYPE_TRIANGLES: 0>, 'mjMESH_PRIMITIVE_TYPE_LINES': <mjrMeshPrimitiveType.mjMESH_PRIMITIVE_TYPE_LINES: 1>}
+    mjMESH_PRIMITIVE_TYPE_LINES: typing.ClassVar[mjrMeshPrimitiveType]  # value = <mjrMeshPrimitiveType.mjMESH_PRIMITIVE_TYPE_LINES: 1>
+    mjMESH_PRIMITIVE_TYPE_TRIANGLES: typing.ClassVar[mjrMeshPrimitiveType]  # value = <mjrMeshPrimitiveType.mjMESH_PRIMITIVE_TYPE_TRIANGLES: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjrPixelFormat:
+    """
+    Members:
+    
+      mjPIXEL_FORMAT_UNKNOWN
+    
+      mjPIXEL_FORMAT_R8
+    
+      mjPIXEL_FORMAT_RGB8
+    
+      mjPIXEL_FORMAT_RGBA8
+    
+      mjPIXEL_FORMAT_R32F
+    
+      mjPIXEL_FORMAT_DEPTH32F
+    
+      mjPIXEL_FORMAT_KTX
+    """
+    __members__: typing.ClassVar[dict[str, mjrPixelFormat]]  # value = {'mjPIXEL_FORMAT_UNKNOWN': <mjrPixelFormat.mjPIXEL_FORMAT_UNKNOWN: 0>, 'mjPIXEL_FORMAT_R8': <mjrPixelFormat.mjPIXEL_FORMAT_R8: 1>, 'mjPIXEL_FORMAT_RGB8': <mjrPixelFormat.mjPIXEL_FORMAT_RGB8: 2>, 'mjPIXEL_FORMAT_RGBA8': <mjrPixelFormat.mjPIXEL_FORMAT_RGBA8: 3>, 'mjPIXEL_FORMAT_R32F': <mjrPixelFormat.mjPIXEL_FORMAT_R32F: 4>, 'mjPIXEL_FORMAT_DEPTH32F': <mjrPixelFormat.mjPIXEL_FORMAT_DEPTH32F: 5>, 'mjPIXEL_FORMAT_KTX': <mjrPixelFormat.mjPIXEL_FORMAT_KTX: 6>}
+    mjPIXEL_FORMAT_DEPTH32F: typing.ClassVar[mjrPixelFormat]  # value = <mjrPixelFormat.mjPIXEL_FORMAT_DEPTH32F: 5>
+    mjPIXEL_FORMAT_KTX: typing.ClassVar[mjrPixelFormat]  # value = <mjrPixelFormat.mjPIXEL_FORMAT_KTX: 6>
+    mjPIXEL_FORMAT_R32F: typing.ClassVar[mjrPixelFormat]  # value = <mjrPixelFormat.mjPIXEL_FORMAT_R32F: 4>
+    mjPIXEL_FORMAT_R8: typing.ClassVar[mjrPixelFormat]  # value = <mjrPixelFormat.mjPIXEL_FORMAT_R8: 1>
+    mjPIXEL_FORMAT_RGB8: typing.ClassVar[mjrPixelFormat]  # value = <mjrPixelFormat.mjPIXEL_FORMAT_RGB8: 2>
+    mjPIXEL_FORMAT_RGBA8: typing.ClassVar[mjrPixelFormat]  # value = <mjrPixelFormat.mjPIXEL_FORMAT_RGBA8: 3>
+    mjPIXEL_FORMAT_UNKNOWN: typing.ClassVar[mjrPixelFormat]  # value = <mjrPixelFormat.mjPIXEL_FORMAT_UNKNOWN: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjrVertexAttributeType:
+    """
+    Members:
+    
+      mjVERTEX_ATTRIBUTE_TYPE_FLOAT2
+    
+      mjVERTEX_ATTRIBUTE_TYPE_FLOAT3
+    
+      mjVERTEX_ATTRIBUTE_TYPE_FLOAT4
+    
+      mjVERTEX_ATTRIBUTE_TYPE_UBYTE4
+    """
+    __members__: typing.ClassVar[dict[str, mjrVertexAttributeType]]  # value = {'mjVERTEX_ATTRIBUTE_TYPE_FLOAT2': <mjrVertexAttributeType.mjVERTEX_ATTRIBUTE_TYPE_FLOAT2: 0>, 'mjVERTEX_ATTRIBUTE_TYPE_FLOAT3': <mjrVertexAttributeType.mjVERTEX_ATTRIBUTE_TYPE_FLOAT3: 1>, 'mjVERTEX_ATTRIBUTE_TYPE_FLOAT4': <mjrVertexAttributeType.mjVERTEX_ATTRIBUTE_TYPE_FLOAT4: 2>, 'mjVERTEX_ATTRIBUTE_TYPE_UBYTE4': <mjrVertexAttributeType.mjVERTEX_ATTRIBUTE_TYPE_UBYTE4: 3>}
+    mjVERTEX_ATTRIBUTE_TYPE_FLOAT2: typing.ClassVar[mjrVertexAttributeType]  # value = <mjrVertexAttributeType.mjVERTEX_ATTRIBUTE_TYPE_FLOAT2: 0>
+    mjVERTEX_ATTRIBUTE_TYPE_FLOAT3: typing.ClassVar[mjrVertexAttributeType]  # value = <mjrVertexAttributeType.mjVERTEX_ATTRIBUTE_TYPE_FLOAT3: 1>
+    mjVERTEX_ATTRIBUTE_TYPE_FLOAT4: typing.ClassVar[mjrVertexAttributeType]  # value = <mjrVertexAttributeType.mjVERTEX_ATTRIBUTE_TYPE_FLOAT4: 2>
+    mjVERTEX_ATTRIBUTE_TYPE_UBYTE4: typing.ClassVar[mjrVertexAttributeType]  # value = <mjrVertexAttributeType.mjVERTEX_ATTRIBUTE_TYPE_UBYTE4: 3>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjrVertexAttributeUsage:
+    """
+    Members:
+    
+      mjVERTEX_ATTRIBUTE_USAGE_POSITION
+    
+      mjVERTEX_ATTRIBUTE_USAGE_NORMAL
+    
+      mjVERTEX_ATTRIBUTE_USAGE_TANGENTS
+    
+      mjVERTEX_ATTRIBUTE_USAGE_UV
+    
+      mjVERTEX_ATTRIBUTE_USAGE_COLOR
+    """
+    __members__: typing.ClassVar[dict[str, mjrVertexAttributeUsage]]  # value = {'mjVERTEX_ATTRIBUTE_USAGE_POSITION': <mjrVertexAttributeUsage.mjVERTEX_ATTRIBUTE_USAGE_POSITION: 0>, 'mjVERTEX_ATTRIBUTE_USAGE_NORMAL': <mjrVertexAttributeUsage.mjVERTEX_ATTRIBUTE_USAGE_NORMAL: 1>, 'mjVERTEX_ATTRIBUTE_USAGE_TANGENTS': <mjrVertexAttributeUsage.mjVERTEX_ATTRIBUTE_USAGE_TANGENTS: 2>, 'mjVERTEX_ATTRIBUTE_USAGE_UV': <mjrVertexAttributeUsage.mjVERTEX_ATTRIBUTE_USAGE_UV: 3>, 'mjVERTEX_ATTRIBUTE_USAGE_COLOR': <mjrVertexAttributeUsage.mjVERTEX_ATTRIBUTE_USAGE_COLOR: 4>}
+    mjVERTEX_ATTRIBUTE_USAGE_COLOR: typing.ClassVar[mjrVertexAttributeUsage]  # value = <mjrVertexAttributeUsage.mjVERTEX_ATTRIBUTE_USAGE_COLOR: 4>
+    mjVERTEX_ATTRIBUTE_USAGE_NORMAL: typing.ClassVar[mjrVertexAttributeUsage]  # value = <mjrVertexAttributeUsage.mjVERTEX_ATTRIBUTE_USAGE_NORMAL: 1>
+    mjVERTEX_ATTRIBUTE_USAGE_POSITION: typing.ClassVar[mjrVertexAttributeUsage]  # value = <mjrVertexAttributeUsage.mjVERTEX_ATTRIBUTE_USAGE_POSITION: 0>
+    mjVERTEX_ATTRIBUTE_USAGE_TANGENTS: typing.ClassVar[mjrVertexAttributeUsage]  # value = <mjrVertexAttributeUsage.mjVERTEX_ATTRIBUTE_USAGE_TANGENTS: 2>
+    mjVERTEX_ATTRIBUTE_USAGE_UV: typing.ClassVar[mjrVertexAttributeUsage]  # value = <mjrVertexAttributeUsage.mjVERTEX_ATTRIBUTE_USAGE_UV: 3>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtAlignFree:
+    """
+    Members:
+    
+      mjALIGNFREE_FALSE
+    
+      mjALIGNFREE_TRUE
+    
+      mjALIGNFREE_AUTO
+    """
+    __members__: typing.ClassVar[dict[str, mjtAlignFree]]  # value = {'mjALIGNFREE_FALSE': <mjtAlignFree.mjALIGNFREE_FALSE: 0>, 'mjALIGNFREE_TRUE': <mjtAlignFree.mjALIGNFREE_TRUE: 1>, 'mjALIGNFREE_AUTO': <mjtAlignFree.mjALIGNFREE_AUTO: 2>}
+    mjALIGNFREE_AUTO: typing.ClassVar[mjtAlignFree]  # value = <mjtAlignFree.mjALIGNFREE_AUTO: 2>
+    mjALIGNFREE_FALSE: typing.ClassVar[mjtAlignFree]  # value = <mjtAlignFree.mjALIGNFREE_FALSE: 0>
+    mjALIGNFREE_TRUE: typing.ClassVar[mjtAlignFree]  # value = <mjtAlignFree.mjALIGNFREE_TRUE: 1>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtBias:
+    """
+    Members:
+    
+      mjBIAS_NONE
+    
+      mjBIAS_AFFINE
+    
+      mjBIAS_MUSCLE
+    
+      mjBIAS_DCMOTOR
+    
+      mjBIAS_SO3
+    
+      mjBIAS_USER
+    """
+    __members__: typing.ClassVar[dict[str, mjtBias]]  # value = {'mjBIAS_NONE': <mjtBias.mjBIAS_NONE: 0>, 'mjBIAS_AFFINE': <mjtBias.mjBIAS_AFFINE: 1>, 'mjBIAS_MUSCLE': <mjtBias.mjBIAS_MUSCLE: 2>, 'mjBIAS_DCMOTOR': <mjtBias.mjBIAS_DCMOTOR: 3>, 'mjBIAS_SO3': <mjtBias.mjBIAS_SO3: 4>, 'mjBIAS_USER': <mjtBias.mjBIAS_USER: 5>}
+    mjBIAS_AFFINE: typing.ClassVar[mjtBias]  # value = <mjtBias.mjBIAS_AFFINE: 1>
+    mjBIAS_DCMOTOR: typing.ClassVar[mjtBias]  # value = <mjtBias.mjBIAS_DCMOTOR: 3>
+    mjBIAS_MUSCLE: typing.ClassVar[mjtBias]  # value = <mjtBias.mjBIAS_MUSCLE: 2>
+    mjBIAS_NONE: typing.ClassVar[mjtBias]  # value = <mjtBias.mjBIAS_NONE: 0>
+    mjBIAS_SO3: typing.ClassVar[mjtBias]  # value = <mjtBias.mjBIAS_SO3: 4>
+    mjBIAS_USER: typing.ClassVar[mjtBias]  # value = <mjtBias.mjBIAS_USER: 5>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtBuiltin:
+    """
+    Members:
+    
+      mjBUILTIN_NONE
+    
+      mjBUILTIN_GRADIENT
+    
+      mjBUILTIN_CHECKER
+    
+      mjBUILTIN_FLAT
+    """
+    __members__: typing.ClassVar[dict[str, mjtBuiltin]]  # value = {'mjBUILTIN_NONE': <mjtBuiltin.mjBUILTIN_NONE: 0>, 'mjBUILTIN_GRADIENT': <mjtBuiltin.mjBUILTIN_GRADIENT: 1>, 'mjBUILTIN_CHECKER': <mjtBuiltin.mjBUILTIN_CHECKER: 2>, 'mjBUILTIN_FLAT': <mjtBuiltin.mjBUILTIN_FLAT: 3>}
+    mjBUILTIN_CHECKER: typing.ClassVar[mjtBuiltin]  # value = <mjtBuiltin.mjBUILTIN_CHECKER: 2>
+    mjBUILTIN_FLAT: typing.ClassVar[mjtBuiltin]  # value = <mjtBuiltin.mjBUILTIN_FLAT: 3>
+    mjBUILTIN_GRADIENT: typing.ClassVar[mjtBuiltin]  # value = <mjtBuiltin.mjBUILTIN_GRADIENT: 1>
+    mjBUILTIN_NONE: typing.ClassVar[mjtBuiltin]  # value = <mjtBuiltin.mjBUILTIN_NONE: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtButton:
+    """
+    Members:
+    
+      mjBUTTON_NONE
+    
+      mjBUTTON_LEFT
+    
+      mjBUTTON_RIGHT
+    
+      mjBUTTON_MIDDLE
+    """
+    __members__: typing.ClassVar[dict[str, mjtButton]]  # value = {'mjBUTTON_NONE': <mjtButton.mjBUTTON_NONE: 0>, 'mjBUTTON_LEFT': <mjtButton.mjBUTTON_LEFT: 1>, 'mjBUTTON_RIGHT': <mjtButton.mjBUTTON_RIGHT: 2>, 'mjBUTTON_MIDDLE': <mjtButton.mjBUTTON_MIDDLE: 3>}
+    mjBUTTON_LEFT: typing.ClassVar[mjtButton]  # value = <mjtButton.mjBUTTON_LEFT: 1>
+    mjBUTTON_MIDDLE: typing.ClassVar[mjtButton]  # value = <mjtButton.mjBUTTON_MIDDLE: 3>
+    mjBUTTON_NONE: typing.ClassVar[mjtButton]  # value = <mjtButton.mjBUTTON_NONE: 0>
+    mjBUTTON_RIGHT: typing.ClassVar[mjtButton]  # value = <mjtButton.mjBUTTON_RIGHT: 2>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtCTimer:
+    """
+    Members:
+    
+      mjCTIMER_TOTAL
+    
+      mjCTIMER_ASSETS
+    
+      mjCTIMER_TEXTURE
+    
+      mjCTIMER_MESH_LOAD
+    
+      mjCTIMER_MESH_HULL
+    
+      mjCTIMER_MESH_POLYGON
+    
+      mjCTIMER_MESH_INERTIA
+    
+      mjCTIMER_MESH_BVH
+    
+      mjCTIMER_MESH_OCTREE
+    
+      mjNCTIMER
+    """
+    __members__: typing.ClassVar[dict[str, mjtCTimer]]  # value = {'mjCTIMER_TOTAL': <mjtCTimer.mjCTIMER_TOTAL: 0>, 'mjCTIMER_ASSETS': <mjtCTimer.mjCTIMER_ASSETS: 1>, 'mjCTIMER_TEXTURE': <mjtCTimer.mjCTIMER_TEXTURE: 2>, 'mjCTIMER_MESH_LOAD': <mjtCTimer.mjCTIMER_MESH_LOAD: 3>, 'mjCTIMER_MESH_HULL': <mjtCTimer.mjCTIMER_MESH_HULL: 4>, 'mjCTIMER_MESH_POLYGON': <mjtCTimer.mjCTIMER_MESH_POLYGON: 5>, 'mjCTIMER_MESH_INERTIA': <mjtCTimer.mjCTIMER_MESH_INERTIA: 6>, 'mjCTIMER_MESH_BVH': <mjtCTimer.mjCTIMER_MESH_BVH: 7>, 'mjCTIMER_MESH_OCTREE': <mjtCTimer.mjCTIMER_MESH_OCTREE: 8>, 'mjNCTIMER': <mjtCTimer.mjNCTIMER: 9>}
+    mjCTIMER_ASSETS: typing.ClassVar[mjtCTimer]  # value = <mjtCTimer.mjCTIMER_ASSETS: 1>
+    mjCTIMER_MESH_BVH: typing.ClassVar[mjtCTimer]  # value = <mjtCTimer.mjCTIMER_MESH_BVH: 7>
+    mjCTIMER_MESH_HULL: typing.ClassVar[mjtCTimer]  # value = <mjtCTimer.mjCTIMER_MESH_HULL: 4>
+    mjCTIMER_MESH_INERTIA: typing.ClassVar[mjtCTimer]  # value = <mjtCTimer.mjCTIMER_MESH_INERTIA: 6>
+    mjCTIMER_MESH_LOAD: typing.ClassVar[mjtCTimer]  # value = <mjtCTimer.mjCTIMER_MESH_LOAD: 3>
+    mjCTIMER_MESH_OCTREE: typing.ClassVar[mjtCTimer]  # value = <mjtCTimer.mjCTIMER_MESH_OCTREE: 8>
+    mjCTIMER_MESH_POLYGON: typing.ClassVar[mjtCTimer]  # value = <mjtCTimer.mjCTIMER_MESH_POLYGON: 5>
+    mjCTIMER_TEXTURE: typing.ClassVar[mjtCTimer]  # value = <mjtCTimer.mjCTIMER_TEXTURE: 2>
+    mjCTIMER_TOTAL: typing.ClassVar[mjtCTimer]  # value = <mjtCTimer.mjCTIMER_TOTAL: 0>
+    mjNCTIMER: typing.ClassVar[mjtCTimer]  # value = <mjtCTimer.mjNCTIMER: 9>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtCamLight:
+    """
+    Members:
+    
+      mjCAMLIGHT_FIXED
+    
+      mjCAMLIGHT_TRACK
+    
+      mjCAMLIGHT_TRACKCOM
+    
+      mjCAMLIGHT_TARGETBODY
+    
+      mjCAMLIGHT_TARGETBODYCOM
+    """
+    __members__: typing.ClassVar[dict[str, mjtCamLight]]  # value = {'mjCAMLIGHT_FIXED': <mjtCamLight.mjCAMLIGHT_FIXED: 0>, 'mjCAMLIGHT_TRACK': <mjtCamLight.mjCAMLIGHT_TRACK: 1>, 'mjCAMLIGHT_TRACKCOM': <mjtCamLight.mjCAMLIGHT_TRACKCOM: 2>, 'mjCAMLIGHT_TARGETBODY': <mjtCamLight.mjCAMLIGHT_TARGETBODY: 3>, 'mjCAMLIGHT_TARGETBODYCOM': <mjtCamLight.mjCAMLIGHT_TARGETBODYCOM: 4>}
+    mjCAMLIGHT_FIXED: typing.ClassVar[mjtCamLight]  # value = <mjtCamLight.mjCAMLIGHT_FIXED: 0>
+    mjCAMLIGHT_TARGETBODY: typing.ClassVar[mjtCamLight]  # value = <mjtCamLight.mjCAMLIGHT_TARGETBODY: 3>
+    mjCAMLIGHT_TARGETBODYCOM: typing.ClassVar[mjtCamLight]  # value = <mjtCamLight.mjCAMLIGHT_TARGETBODYCOM: 4>
+    mjCAMLIGHT_TRACK: typing.ClassVar[mjtCamLight]  # value = <mjtCamLight.mjCAMLIGHT_TRACK: 1>
+    mjCAMLIGHT_TRACKCOM: typing.ClassVar[mjtCamLight]  # value = <mjtCamLight.mjCAMLIGHT_TRACKCOM: 2>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtCamOutBit:
+    """
+    Members:
+    
+      mjCAMOUT_RGB
+    
+      mjCAMOUT_DEPTH
+    
+      mjCAMOUT_DIST
+    
+      mjCAMOUT_NORMAL
+    
+      mjCAMOUT_SEG
+    
+      mjNCAMOUT
+    """
+    __members__: typing.ClassVar[dict[str, mjtCamOutBit]]  # value = {'mjCAMOUT_RGB': <mjtCamOutBit.mjCAMOUT_RGB: 1>, 'mjCAMOUT_DEPTH': <mjtCamOutBit.mjCAMOUT_DEPTH: 2>, 'mjCAMOUT_DIST': <mjtCamOutBit.mjCAMOUT_DIST: 4>, 'mjCAMOUT_NORMAL': <mjtCamOutBit.mjCAMOUT_NORMAL: 8>, 'mjCAMOUT_SEG': <mjtCamOutBit.mjCAMOUT_SEG: 16>, 'mjNCAMOUT': <mjtCamOutBit.mjNCAMOUT: 5>}
+    mjCAMOUT_DEPTH: typing.ClassVar[mjtCamOutBit]  # value = <mjtCamOutBit.mjCAMOUT_DEPTH: 2>
+    mjCAMOUT_DIST: typing.ClassVar[mjtCamOutBit]  # value = <mjtCamOutBit.mjCAMOUT_DIST: 4>
+    mjCAMOUT_NORMAL: typing.ClassVar[mjtCamOutBit]  # value = <mjtCamOutBit.mjCAMOUT_NORMAL: 8>
+    mjCAMOUT_RGB: typing.ClassVar[mjtCamOutBit]  # value = <mjtCamOutBit.mjCAMOUT_RGB: 1>
+    mjCAMOUT_SEG: typing.ClassVar[mjtCamOutBit]  # value = <mjtCamOutBit.mjCAMOUT_SEG: 16>
+    mjNCAMOUT: typing.ClassVar[mjtCamOutBit]  # value = <mjtCamOutBit.mjNCAMOUT: 5>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtCamera:
+    """
+    Members:
+    
+      mjCAMERA_FREE
+    
+      mjCAMERA_TRACKING
+    
+      mjCAMERA_FIXED
+    
+      mjCAMERA_USER
+    """
+    __members__: typing.ClassVar[dict[str, mjtCamera]]  # value = {'mjCAMERA_FREE': <mjtCamera.mjCAMERA_FREE: 0>, 'mjCAMERA_TRACKING': <mjtCamera.mjCAMERA_TRACKING: 1>, 'mjCAMERA_FIXED': <mjtCamera.mjCAMERA_FIXED: 2>, 'mjCAMERA_USER': <mjtCamera.mjCAMERA_USER: 3>}
+    mjCAMERA_FIXED: typing.ClassVar[mjtCamera]  # value = <mjtCamera.mjCAMERA_FIXED: 2>
+    mjCAMERA_FREE: typing.ClassVar[mjtCamera]  # value = <mjtCamera.mjCAMERA_FREE: 0>
+    mjCAMERA_TRACKING: typing.ClassVar[mjtCamera]  # value = <mjtCamera.mjCAMERA_TRACKING: 1>
+    mjCAMERA_USER: typing.ClassVar[mjtCamera]  # value = <mjtCamera.mjCAMERA_USER: 3>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtCatBit:
+    """
+    Members:
+    
+      mjCAT_STATIC
+    
+      mjCAT_DYNAMIC
+    
+      mjCAT_DECOR
+    
+      mjCAT_ALL
+    """
+    __members__: typing.ClassVar[dict[str, mjtCatBit]]  # value = {'mjCAT_STATIC': <mjtCatBit.mjCAT_STATIC: 1>, 'mjCAT_DYNAMIC': <mjtCatBit.mjCAT_DYNAMIC: 2>, 'mjCAT_DECOR': <mjtCatBit.mjCAT_DECOR: 4>, 'mjCAT_ALL': <mjtCatBit.mjCAT_ALL: 7>}
+    mjCAT_ALL: typing.ClassVar[mjtCatBit]  # value = <mjtCatBit.mjCAT_ALL: 7>
+    mjCAT_DECOR: typing.ClassVar[mjtCatBit]  # value = <mjtCatBit.mjCAT_DECOR: 4>
+    mjCAT_DYNAMIC: typing.ClassVar[mjtCatBit]  # value = <mjtCatBit.mjCAT_DYNAMIC: 2>
+    mjCAT_STATIC: typing.ClassVar[mjtCatBit]  # value = <mjtCatBit.mjCAT_STATIC: 1>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtColorSpace:
+    """
+    Members:
+    
+      mjCOLORSPACE_AUTO
+    
+      mjCOLORSPACE_LINEAR
+    
+      mjCOLORSPACE_SRGB
+    """
+    __members__: typing.ClassVar[dict[str, mjtColorSpace]]  # value = {'mjCOLORSPACE_AUTO': <mjtColorSpace.mjCOLORSPACE_AUTO: 0>, 'mjCOLORSPACE_LINEAR': <mjtColorSpace.mjCOLORSPACE_LINEAR: 1>, 'mjCOLORSPACE_SRGB': <mjtColorSpace.mjCOLORSPACE_SRGB: 2>}
+    mjCOLORSPACE_AUTO: typing.ClassVar[mjtColorSpace]  # value = <mjtColorSpace.mjCOLORSPACE_AUTO: 0>
+    mjCOLORSPACE_LINEAR: typing.ClassVar[mjtColorSpace]  # value = <mjtColorSpace.mjCOLORSPACE_LINEAR: 1>
+    mjCOLORSPACE_SRGB: typing.ClassVar[mjtColorSpace]  # value = <mjtColorSpace.mjCOLORSPACE_SRGB: 2>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtConDataField:
+    """
+    Members:
+    
+      mjCONDATA_FOUND
+    
+      mjCONDATA_FORCE
+    
+      mjCONDATA_TORQUE
+    
+      mjCONDATA_DIST
+    
+      mjCONDATA_POS
+    
+      mjCONDATA_NORMAL
+    
+      mjCONDATA_TANGENT
+    
+      mjNCONDATA
+    """
+    __members__: typing.ClassVar[dict[str, mjtConDataField]]  # value = {'mjCONDATA_FOUND': <mjtConDataField.mjCONDATA_FOUND: 0>, 'mjCONDATA_FORCE': <mjtConDataField.mjCONDATA_FORCE: 1>, 'mjCONDATA_TORQUE': <mjtConDataField.mjCONDATA_TORQUE: 2>, 'mjCONDATA_DIST': <mjtConDataField.mjCONDATA_DIST: 3>, 'mjCONDATA_POS': <mjtConDataField.mjCONDATA_POS: 4>, 'mjCONDATA_NORMAL': <mjtConDataField.mjCONDATA_NORMAL: 5>, 'mjCONDATA_TANGENT': <mjtConDataField.mjCONDATA_TANGENT: 6>, 'mjNCONDATA': <mjtConDataField.mjNCONDATA: 7>}
+    mjCONDATA_DIST: typing.ClassVar[mjtConDataField]  # value = <mjtConDataField.mjCONDATA_DIST: 3>
+    mjCONDATA_FORCE: typing.ClassVar[mjtConDataField]  # value = <mjtConDataField.mjCONDATA_FORCE: 1>
+    mjCONDATA_FOUND: typing.ClassVar[mjtConDataField]  # value = <mjtConDataField.mjCONDATA_FOUND: 0>
+    mjCONDATA_NORMAL: typing.ClassVar[mjtConDataField]  # value = <mjtConDataField.mjCONDATA_NORMAL: 5>
+    mjCONDATA_POS: typing.ClassVar[mjtConDataField]  # value = <mjtConDataField.mjCONDATA_POS: 4>
+    mjCONDATA_TANGENT: typing.ClassVar[mjtConDataField]  # value = <mjtConDataField.mjCONDATA_TANGENT: 6>
+    mjCONDATA_TORQUE: typing.ClassVar[mjtConDataField]  # value = <mjtConDataField.mjCONDATA_TORQUE: 2>
+    mjNCONDATA: typing.ClassVar[mjtConDataField]  # value = <mjtConDataField.mjNCONDATA: 7>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtCone:
+    """
+    Members:
+    
+      mjCONE_PYRAMIDAL
+    
+      mjCONE_ELLIPTIC
+    """
+    __members__: typing.ClassVar[dict[str, mjtCone]]  # value = {'mjCONE_PYRAMIDAL': <mjtCone.mjCONE_PYRAMIDAL: 0>, 'mjCONE_ELLIPTIC': <mjtCone.mjCONE_ELLIPTIC: 1>}
+    mjCONE_ELLIPTIC: typing.ClassVar[mjtCone]  # value = <mjtCone.mjCONE_ELLIPTIC: 1>
+    mjCONE_PYRAMIDAL: typing.ClassVar[mjtCone]  # value = <mjtCone.mjCONE_PYRAMIDAL: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtConflict:
+    """
+    Members:
+    
+      mjCONFLICT_WARNING
+    
+      mjCONFLICT_MERGE
+    
+      mjCONFLICT_ERROR
+    """
+    __members__: typing.ClassVar[dict[str, mjtConflict]]  # value = {'mjCONFLICT_WARNING': <mjtConflict.mjCONFLICT_WARNING: 0>, 'mjCONFLICT_MERGE': <mjtConflict.mjCONFLICT_MERGE: 1>, 'mjCONFLICT_ERROR': <mjtConflict.mjCONFLICT_ERROR: 2>}
+    mjCONFLICT_ERROR: typing.ClassVar[mjtConflict]  # value = <mjtConflict.mjCONFLICT_ERROR: 2>
+    mjCONFLICT_MERGE: typing.ClassVar[mjtConflict]  # value = <mjtConflict.mjCONFLICT_MERGE: 1>
+    mjCONFLICT_WARNING: typing.ClassVar[mjtConflict]  # value = <mjtConflict.mjCONFLICT_WARNING: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtConstraint:
+    """
+    Members:
+    
+      mjCNSTR_EQUALITY
+    
+      mjCNSTR_FRICTION_DOF
+    
+      mjCNSTR_FRICTION_TENDON
+    
+      mjCNSTR_LIMIT_JOINT
+    
+      mjCNSTR_LIMIT_TENDON
+    
+      mjCNSTR_CONTACT_FRICTIONLESS
+    
+      mjCNSTR_CONTACT_PYRAMIDAL
+    
+      mjCNSTR_CONTACT_ELLIPTIC
+    """
+    __members__: typing.ClassVar[dict[str, mjtConstraint]]  # value = {'mjCNSTR_EQUALITY': <mjtConstraint.mjCNSTR_EQUALITY: 0>, 'mjCNSTR_FRICTION_DOF': <mjtConstraint.mjCNSTR_FRICTION_DOF: 1>, 'mjCNSTR_FRICTION_TENDON': <mjtConstraint.mjCNSTR_FRICTION_TENDON: 2>, 'mjCNSTR_LIMIT_JOINT': <mjtConstraint.mjCNSTR_LIMIT_JOINT: 3>, 'mjCNSTR_LIMIT_TENDON': <mjtConstraint.mjCNSTR_LIMIT_TENDON: 4>, 'mjCNSTR_CONTACT_FRICTIONLESS': <mjtConstraint.mjCNSTR_CONTACT_FRICTIONLESS: 5>, 'mjCNSTR_CONTACT_PYRAMIDAL': <mjtConstraint.mjCNSTR_CONTACT_PYRAMIDAL: 6>, 'mjCNSTR_CONTACT_ELLIPTIC': <mjtConstraint.mjCNSTR_CONTACT_ELLIPTIC: 7>}
+    mjCNSTR_CONTACT_ELLIPTIC: typing.ClassVar[mjtConstraint]  # value = <mjtConstraint.mjCNSTR_CONTACT_ELLIPTIC: 7>
+    mjCNSTR_CONTACT_FRICTIONLESS: typing.ClassVar[mjtConstraint]  # value = <mjtConstraint.mjCNSTR_CONTACT_FRICTIONLESS: 5>
+    mjCNSTR_CONTACT_PYRAMIDAL: typing.ClassVar[mjtConstraint]  # value = <mjtConstraint.mjCNSTR_CONTACT_PYRAMIDAL: 6>
+    mjCNSTR_EQUALITY: typing.ClassVar[mjtConstraint]  # value = <mjtConstraint.mjCNSTR_EQUALITY: 0>
+    mjCNSTR_FRICTION_DOF: typing.ClassVar[mjtConstraint]  # value = <mjtConstraint.mjCNSTR_FRICTION_DOF: 1>
+    mjCNSTR_FRICTION_TENDON: typing.ClassVar[mjtConstraint]  # value = <mjtConstraint.mjCNSTR_FRICTION_TENDON: 2>
+    mjCNSTR_LIMIT_JOINT: typing.ClassVar[mjtConstraint]  # value = <mjtConstraint.mjCNSTR_LIMIT_JOINT: 3>
+    mjCNSTR_LIMIT_TENDON: typing.ClassVar[mjtConstraint]  # value = <mjtConstraint.mjCNSTR_LIMIT_TENDON: 4>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtConstraintState:
+    """
+    Members:
+    
+      mjCNSTRSTATE_SATISFIED
+    
+      mjCNSTRSTATE_QUADRATIC
+    
+      mjCNSTRSTATE_LINEARNEG
+    
+      mjCNSTRSTATE_LINEARPOS
+    
+      mjCNSTRSTATE_CONE
+    """
+    __members__: typing.ClassVar[dict[str, mjtConstraintState]]  # value = {'mjCNSTRSTATE_SATISFIED': <mjtConstraintState.mjCNSTRSTATE_SATISFIED: 0>, 'mjCNSTRSTATE_QUADRATIC': <mjtConstraintState.mjCNSTRSTATE_QUADRATIC: 1>, 'mjCNSTRSTATE_LINEARNEG': <mjtConstraintState.mjCNSTRSTATE_LINEARNEG: 2>, 'mjCNSTRSTATE_LINEARPOS': <mjtConstraintState.mjCNSTRSTATE_LINEARPOS: 3>, 'mjCNSTRSTATE_CONE': <mjtConstraintState.mjCNSTRSTATE_CONE: 4>}
+    mjCNSTRSTATE_CONE: typing.ClassVar[mjtConstraintState]  # value = <mjtConstraintState.mjCNSTRSTATE_CONE: 4>
+    mjCNSTRSTATE_LINEARNEG: typing.ClassVar[mjtConstraintState]  # value = <mjtConstraintState.mjCNSTRSTATE_LINEARNEG: 2>
+    mjCNSTRSTATE_LINEARPOS: typing.ClassVar[mjtConstraintState]  # value = <mjtConstraintState.mjCNSTRSTATE_LINEARPOS: 3>
+    mjCNSTRSTATE_QUADRATIC: typing.ClassVar[mjtConstraintState]  # value = <mjtConstraintState.mjCNSTRSTATE_QUADRATIC: 1>
+    mjCNSTRSTATE_SATISFIED: typing.ClassVar[mjtConstraintState]  # value = <mjtConstraintState.mjCNSTRSTATE_SATISFIED: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtCtrlChart:
+    """
+    Members:
+    
+      mjCHART_EXPMAP
+    
+      mjCHART_QUAT
+    """
+    __members__: typing.ClassVar[dict[str, mjtCtrlChart]]  # value = {'mjCHART_EXPMAP': <mjtCtrlChart.mjCHART_EXPMAP: 1>, 'mjCHART_QUAT': <mjtCtrlChart.mjCHART_QUAT: 2>}
+    mjCHART_EXPMAP: typing.ClassVar[mjtCtrlChart]  # value = <mjtCtrlChart.mjCHART_EXPMAP: 1>
+    mjCHART_QUAT: typing.ClassVar[mjtCtrlChart]  # value = <mjtCtrlChart.mjCHART_QUAT: 2>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtDataType:
+    """
+    Members:
+    
+      mjDATATYPE_REAL
+    
+      mjDATATYPE_POSITIVE
+    
+      mjDATATYPE_AXIS
+    
+      mjDATATYPE_QUATERNION
+    """
+    __members__: typing.ClassVar[dict[str, mjtDataType]]  # value = {'mjDATATYPE_REAL': <mjtDataType.mjDATATYPE_REAL: 0>, 'mjDATATYPE_POSITIVE': <mjtDataType.mjDATATYPE_POSITIVE: 1>, 'mjDATATYPE_AXIS': <mjtDataType.mjDATATYPE_AXIS: 2>, 'mjDATATYPE_QUATERNION': <mjtDataType.mjDATATYPE_QUATERNION: 3>}
+    mjDATATYPE_AXIS: typing.ClassVar[mjtDataType]  # value = <mjtDataType.mjDATATYPE_AXIS: 2>
+    mjDATATYPE_POSITIVE: typing.ClassVar[mjtDataType]  # value = <mjtDataType.mjDATATYPE_POSITIVE: 1>
+    mjDATATYPE_QUATERNION: typing.ClassVar[mjtDataType]  # value = <mjtDataType.mjDATATYPE_QUATERNION: 3>
+    mjDATATYPE_REAL: typing.ClassVar[mjtDataType]  # value = <mjtDataType.mjDATATYPE_REAL: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtDepthMap:
+    """
+    Members:
+    
+      mjDEPTH_ZERONEAR
+    
+      mjDEPTH_ZEROFAR
+    """
+    __members__: typing.ClassVar[dict[str, mjtDepthMap]]  # value = {'mjDEPTH_ZERONEAR': <mjtDepthMap.mjDEPTH_ZERONEAR: 0>, 'mjDEPTH_ZEROFAR': <mjtDepthMap.mjDEPTH_ZEROFAR: 1>}
+    mjDEPTH_ZEROFAR: typing.ClassVar[mjtDepthMap]  # value = <mjtDepthMap.mjDEPTH_ZEROFAR: 1>
+    mjDEPTH_ZERONEAR: typing.ClassVar[mjtDepthMap]  # value = <mjtDepthMap.mjDEPTH_ZERONEAR: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtDisableBit:
+    """
+    Members:
+    
+      mjDSBL_CONSTRAINT
+    
+      mjDSBL_EQUALITY
+    
+      mjDSBL_FRICTIONLOSS
+    
+      mjDSBL_LIMIT
+    
+      mjDSBL_CONTACT
+    
+      mjDSBL_SPRING
+    
+      mjDSBL_DAMPER
+    
+      mjDSBL_GRAVITY
+    
+      mjDSBL_CLAMPCTRL
+    
+      mjDSBL_WARMSTART
+    
+      mjDSBL_FILTERPARENT
+    
+      mjDSBL_ACTUATION
+    
+      mjDSBL_REFSAFE
+    
+      mjDSBL_SENSOR
+    
+      mjDSBL_MIDPHASE
+    
+      mjDSBL_EULERDAMP
+    
+      mjDSBL_AUTORESET
+    
+      mjDSBL_NATIVECCD
+    
+      mjDSBL_ISLAND
+    
+      mjDSBL_MULTICCD
+    
+      mjNDISABLE
+    """
+    __members__: typing.ClassVar[dict[str, mjtDisableBit]]  # value = {'mjDSBL_CONSTRAINT': <mjtDisableBit.mjDSBL_CONSTRAINT: 1>, 'mjDSBL_EQUALITY': <mjtDisableBit.mjDSBL_EQUALITY: 2>, 'mjDSBL_FRICTIONLOSS': <mjtDisableBit.mjDSBL_FRICTIONLOSS: 4>, 'mjDSBL_LIMIT': <mjtDisableBit.mjDSBL_LIMIT: 8>, 'mjDSBL_CONTACT': <mjtDisableBit.mjDSBL_CONTACT: 16>, 'mjDSBL_SPRING': <mjtDisableBit.mjDSBL_SPRING: 32>, 'mjDSBL_DAMPER': <mjtDisableBit.mjDSBL_DAMPER: 64>, 'mjDSBL_GRAVITY': <mjtDisableBit.mjDSBL_GRAVITY: 128>, 'mjDSBL_CLAMPCTRL': <mjtDisableBit.mjDSBL_CLAMPCTRL: 256>, 'mjDSBL_WARMSTART': <mjtDisableBit.mjDSBL_WARMSTART: 512>, 'mjDSBL_FILTERPARENT': <mjtDisableBit.mjDSBL_FILTERPARENT: 1024>, 'mjDSBL_ACTUATION': <mjtDisableBit.mjDSBL_ACTUATION: 2048>, 'mjDSBL_REFSAFE': <mjtDisableBit.mjDSBL_REFSAFE: 4096>, 'mjDSBL_SENSOR': <mjtDisableBit.mjDSBL_SENSOR: 8192>, 'mjDSBL_MIDPHASE': <mjtDisableBit.mjDSBL_MIDPHASE: 16384>, 'mjDSBL_EULERDAMP': <mjtDisableBit.mjDSBL_EULERDAMP: 32768>, 'mjDSBL_AUTORESET': <mjtDisableBit.mjDSBL_AUTORESET: 65536>, 'mjDSBL_NATIVECCD': <mjtDisableBit.mjDSBL_NATIVECCD: 131072>, 'mjDSBL_ISLAND': <mjtDisableBit.mjDSBL_ISLAND: 262144>, 'mjDSBL_MULTICCD': <mjtDisableBit.mjDSBL_MULTICCD: 524288>, 'mjNDISABLE': <mjtDisableBit.mjNDISABLE: 20>}
+    mjDSBL_ACTUATION: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_ACTUATION: 2048>
+    mjDSBL_AUTORESET: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_AUTORESET: 65536>
+    mjDSBL_CLAMPCTRL: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_CLAMPCTRL: 256>
+    mjDSBL_CONSTRAINT: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_CONSTRAINT: 1>
+    mjDSBL_CONTACT: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_CONTACT: 16>
+    mjDSBL_DAMPER: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_DAMPER: 64>
+    mjDSBL_EQUALITY: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_EQUALITY: 2>
+    mjDSBL_EULERDAMP: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_EULERDAMP: 32768>
+    mjDSBL_FILTERPARENT: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_FILTERPARENT: 1024>
+    mjDSBL_FRICTIONLOSS: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_FRICTIONLOSS: 4>
+    mjDSBL_GRAVITY: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_GRAVITY: 128>
+    mjDSBL_ISLAND: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_ISLAND: 262144>
+    mjDSBL_LIMIT: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_LIMIT: 8>
+    mjDSBL_MIDPHASE: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_MIDPHASE: 16384>
+    mjDSBL_MULTICCD: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_MULTICCD: 524288>
+    mjDSBL_NATIVECCD: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_NATIVECCD: 131072>
+    mjDSBL_REFSAFE: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_REFSAFE: 4096>
+    mjDSBL_SENSOR: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_SENSOR: 8192>
+    mjDSBL_SPRING: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_SPRING: 32>
+    mjDSBL_WARMSTART: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjDSBL_WARMSTART: 512>
+    mjNDISABLE: typing.ClassVar[mjtDisableBit]  # value = <mjtDisableBit.mjNDISABLE: 20>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtDyn:
+    """
+    Members:
+    
+      mjDYN_NONE
+    
+      mjDYN_INTEGRATOR
+    
+      mjDYN_FILTER
+    
+      mjDYN_FILTEREXACT
+    
+      mjDYN_MUSCLE
+    
+      mjDYN_DCMOTOR
+    
+      mjDYN_USER
+    """
+    __members__: typing.ClassVar[dict[str, mjtDyn]]  # value = {'mjDYN_NONE': <mjtDyn.mjDYN_NONE: 0>, 'mjDYN_INTEGRATOR': <mjtDyn.mjDYN_INTEGRATOR: 1>, 'mjDYN_FILTER': <mjtDyn.mjDYN_FILTER: 2>, 'mjDYN_FILTEREXACT': <mjtDyn.mjDYN_FILTEREXACT: 3>, 'mjDYN_MUSCLE': <mjtDyn.mjDYN_MUSCLE: 4>, 'mjDYN_DCMOTOR': <mjtDyn.mjDYN_DCMOTOR: 5>, 'mjDYN_USER': <mjtDyn.mjDYN_USER: 6>}
+    mjDYN_DCMOTOR: typing.ClassVar[mjtDyn]  # value = <mjtDyn.mjDYN_DCMOTOR: 5>
+    mjDYN_FILTER: typing.ClassVar[mjtDyn]  # value = <mjtDyn.mjDYN_FILTER: 2>
+    mjDYN_FILTEREXACT: typing.ClassVar[mjtDyn]  # value = <mjtDyn.mjDYN_FILTEREXACT: 3>
+    mjDYN_INTEGRATOR: typing.ClassVar[mjtDyn]  # value = <mjtDyn.mjDYN_INTEGRATOR: 1>
+    mjDYN_MUSCLE: typing.ClassVar[mjtDyn]  # value = <mjtDyn.mjDYN_MUSCLE: 4>
+    mjDYN_NONE: typing.ClassVar[mjtDyn]  # value = <mjtDyn.mjDYN_NONE: 0>
+    mjDYN_USER: typing.ClassVar[mjtDyn]  # value = <mjtDyn.mjDYN_USER: 6>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtEnableBit:
+    """
+    Members:
+    
+      mjENBL_OVERRIDE
+    
+      mjENBL_ENERGY
+    
+      mjENBL_FWDINV
+    
+      mjENBL_INVDISCRETE
+    
+      mjENBL_SLEEP
+    
+      mjENBL_DIAGEXACT
+    
+      mjNENABLE
+    """
+    __members__: typing.ClassVar[dict[str, mjtEnableBit]]  # value = {'mjENBL_OVERRIDE': <mjtEnableBit.mjENBL_OVERRIDE: 1>, 'mjENBL_ENERGY': <mjtEnableBit.mjENBL_ENERGY: 2>, 'mjENBL_FWDINV': <mjtEnableBit.mjENBL_FWDINV: 4>, 'mjENBL_INVDISCRETE': <mjtEnableBit.mjENBL_INVDISCRETE: 8>, 'mjENBL_SLEEP': <mjtEnableBit.mjENBL_SLEEP: 16>, 'mjENBL_DIAGEXACT': <mjtEnableBit.mjENBL_DIAGEXACT: 32>, 'mjNENABLE': <mjtEnableBit.mjNENABLE: 6>}
+    mjENBL_DIAGEXACT: typing.ClassVar[mjtEnableBit]  # value = <mjtEnableBit.mjENBL_DIAGEXACT: 32>
+    mjENBL_ENERGY: typing.ClassVar[mjtEnableBit]  # value = <mjtEnableBit.mjENBL_ENERGY: 2>
+    mjENBL_FWDINV: typing.ClassVar[mjtEnableBit]  # value = <mjtEnableBit.mjENBL_FWDINV: 4>
+    mjENBL_INVDISCRETE: typing.ClassVar[mjtEnableBit]  # value = <mjtEnableBit.mjENBL_INVDISCRETE: 8>
+    mjENBL_OVERRIDE: typing.ClassVar[mjtEnableBit]  # value = <mjtEnableBit.mjENBL_OVERRIDE: 1>
+    mjENBL_SLEEP: typing.ClassVar[mjtEnableBit]  # value = <mjtEnableBit.mjENBL_SLEEP: 16>
+    mjNENABLE: typing.ClassVar[mjtEnableBit]  # value = <mjtEnableBit.mjNENABLE: 6>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtEq:
+    """
+    Members:
+    
+      mjEQ_CONNECT
+    
+      mjEQ_WELD
+    
+      mjEQ_JOINT
+    
+      mjEQ_TENDON
+    
+      mjEQ_FLEX
+    
+      mjEQ_FLEXVERT
+    
+      mjEQ_FLEXSTRAIN
+    
+      mjEQ_DISTANCE
+    """
+    __members__: typing.ClassVar[dict[str, mjtEq]]  # value = {'mjEQ_CONNECT': <mjtEq.mjEQ_CONNECT: 0>, 'mjEQ_WELD': <mjtEq.mjEQ_WELD: 1>, 'mjEQ_JOINT': <mjtEq.mjEQ_JOINT: 2>, 'mjEQ_TENDON': <mjtEq.mjEQ_TENDON: 3>, 'mjEQ_FLEX': <mjtEq.mjEQ_FLEX: 4>, 'mjEQ_FLEXVERT': <mjtEq.mjEQ_FLEXVERT: 5>, 'mjEQ_FLEXSTRAIN': <mjtEq.mjEQ_FLEXSTRAIN: 6>, 'mjEQ_DISTANCE': <mjtEq.mjEQ_DISTANCE: 7>}
+    mjEQ_CONNECT: typing.ClassVar[mjtEq]  # value = <mjtEq.mjEQ_CONNECT: 0>
+    mjEQ_DISTANCE: typing.ClassVar[mjtEq]  # value = <mjtEq.mjEQ_DISTANCE: 7>
+    mjEQ_FLEX: typing.ClassVar[mjtEq]  # value = <mjtEq.mjEQ_FLEX: 4>
+    mjEQ_FLEXSTRAIN: typing.ClassVar[mjtEq]  # value = <mjtEq.mjEQ_FLEXSTRAIN: 6>
+    mjEQ_FLEXVERT: typing.ClassVar[mjtEq]  # value = <mjtEq.mjEQ_FLEXVERT: 5>
+    mjEQ_JOINT: typing.ClassVar[mjtEq]  # value = <mjtEq.mjEQ_JOINT: 2>
+    mjEQ_TENDON: typing.ClassVar[mjtEq]  # value = <mjtEq.mjEQ_TENDON: 3>
+    mjEQ_WELD: typing.ClassVar[mjtEq]  # value = <mjtEq.mjEQ_WELD: 1>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtEvent:
+    """
+    Members:
+    
+      mjEVENT_NONE
+    
+      mjEVENT_MOVE
+    
+      mjEVENT_PRESS
+    
+      mjEVENT_RELEASE
+    
+      mjEVENT_SCROLL
+    
+      mjEVENT_KEY
+    
+      mjEVENT_RESIZE
+    
+      mjEVENT_REDRAW
+    
+      mjEVENT_FILESDROP
+    """
+    __members__: typing.ClassVar[dict[str, mjtEvent]]  # value = {'mjEVENT_NONE': <mjtEvent.mjEVENT_NONE: 0>, 'mjEVENT_MOVE': <mjtEvent.mjEVENT_MOVE: 1>, 'mjEVENT_PRESS': <mjtEvent.mjEVENT_PRESS: 2>, 'mjEVENT_RELEASE': <mjtEvent.mjEVENT_RELEASE: 3>, 'mjEVENT_SCROLL': <mjtEvent.mjEVENT_SCROLL: 4>, 'mjEVENT_KEY': <mjtEvent.mjEVENT_KEY: 5>, 'mjEVENT_RESIZE': <mjtEvent.mjEVENT_RESIZE: 6>, 'mjEVENT_REDRAW': <mjtEvent.mjEVENT_REDRAW: 7>, 'mjEVENT_FILESDROP': <mjtEvent.mjEVENT_FILESDROP: 8>}
+    mjEVENT_FILESDROP: typing.ClassVar[mjtEvent]  # value = <mjtEvent.mjEVENT_FILESDROP: 8>
+    mjEVENT_KEY: typing.ClassVar[mjtEvent]  # value = <mjtEvent.mjEVENT_KEY: 5>
+    mjEVENT_MOVE: typing.ClassVar[mjtEvent]  # value = <mjtEvent.mjEVENT_MOVE: 1>
+    mjEVENT_NONE: typing.ClassVar[mjtEvent]  # value = <mjtEvent.mjEVENT_NONE: 0>
+    mjEVENT_PRESS: typing.ClassVar[mjtEvent]  # value = <mjtEvent.mjEVENT_PRESS: 2>
+    mjEVENT_REDRAW: typing.ClassVar[mjtEvent]  # value = <mjtEvent.mjEVENT_REDRAW: 7>
+    mjEVENT_RELEASE: typing.ClassVar[mjtEvent]  # value = <mjtEvent.mjEVENT_RELEASE: 3>
+    mjEVENT_RESIZE: typing.ClassVar[mjtEvent]  # value = <mjtEvent.mjEVENT_RESIZE: 6>
+    mjEVENT_SCROLL: typing.ClassVar[mjtEvent]  # value = <mjtEvent.mjEVENT_SCROLL: 4>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtFlexSelf:
+    """
+    Members:
+    
+      mjFLEXSELF_NONE
+    
+      mjFLEXSELF_NARROW
+    
+      mjFLEXSELF_BVH
+    
+      mjFLEXSELF_SAP
+    
+      mjFLEXSELF_AUTO
+    """
+    __members__: typing.ClassVar[dict[str, mjtFlexSelf]]  # value = {'mjFLEXSELF_NONE': <mjtFlexSelf.mjFLEXSELF_NONE: 0>, 'mjFLEXSELF_NARROW': <mjtFlexSelf.mjFLEXSELF_NARROW: 1>, 'mjFLEXSELF_BVH': <mjtFlexSelf.mjFLEXSELF_BVH: 2>, 'mjFLEXSELF_SAP': <mjtFlexSelf.mjFLEXSELF_SAP: 3>, 'mjFLEXSELF_AUTO': <mjtFlexSelf.mjFLEXSELF_AUTO: 4>}
+    mjFLEXSELF_AUTO: typing.ClassVar[mjtFlexSelf]  # value = <mjtFlexSelf.mjFLEXSELF_AUTO: 4>
+    mjFLEXSELF_BVH: typing.ClassVar[mjtFlexSelf]  # value = <mjtFlexSelf.mjFLEXSELF_BVH: 2>
+    mjFLEXSELF_NARROW: typing.ClassVar[mjtFlexSelf]  # value = <mjtFlexSelf.mjFLEXSELF_NARROW: 1>
+    mjFLEXSELF_NONE: typing.ClassVar[mjtFlexSelf]  # value = <mjtFlexSelf.mjFLEXSELF_NONE: 0>
+    mjFLEXSELF_SAP: typing.ClassVar[mjtFlexSelf]  # value = <mjtFlexSelf.mjFLEXSELF_SAP: 3>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtFont:
+    """
+    Members:
+    
+      mjFONT_NORMAL
+    
+      mjFONT_SHADOW
+    
+      mjFONT_BIG
+    """
+    __members__: typing.ClassVar[dict[str, mjtFont]]  # value = {'mjFONT_NORMAL': <mjtFont.mjFONT_NORMAL: 0>, 'mjFONT_SHADOW': <mjtFont.mjFONT_SHADOW: 1>, 'mjFONT_BIG': <mjtFont.mjFONT_BIG: 2>}
+    mjFONT_BIG: typing.ClassVar[mjtFont]  # value = <mjtFont.mjFONT_BIG: 2>
+    mjFONT_NORMAL: typing.ClassVar[mjtFont]  # value = <mjtFont.mjFONT_NORMAL: 0>
+    mjFONT_SHADOW: typing.ClassVar[mjtFont]  # value = <mjtFont.mjFONT_SHADOW: 1>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtFontScale:
+    """
+    Members:
+    
+      mjFONTSCALE_50
+    
+      mjFONTSCALE_100
+    
+      mjFONTSCALE_150
+    
+      mjFONTSCALE_200
+    
+      mjFONTSCALE_250
+    
+      mjFONTSCALE_300
+    """
+    __members__: typing.ClassVar[dict[str, mjtFontScale]]  # value = {'mjFONTSCALE_50': <mjtFontScale.mjFONTSCALE_50: 50>, 'mjFONTSCALE_100': <mjtFontScale.mjFONTSCALE_100: 100>, 'mjFONTSCALE_150': <mjtFontScale.mjFONTSCALE_150: 150>, 'mjFONTSCALE_200': <mjtFontScale.mjFONTSCALE_200: 200>, 'mjFONTSCALE_250': <mjtFontScale.mjFONTSCALE_250: 250>, 'mjFONTSCALE_300': <mjtFontScale.mjFONTSCALE_300: 300>}
+    mjFONTSCALE_100: typing.ClassVar[mjtFontScale]  # value = <mjtFontScale.mjFONTSCALE_100: 100>
+    mjFONTSCALE_150: typing.ClassVar[mjtFontScale]  # value = <mjtFontScale.mjFONTSCALE_150: 150>
+    mjFONTSCALE_200: typing.ClassVar[mjtFontScale]  # value = <mjtFontScale.mjFONTSCALE_200: 200>
+    mjFONTSCALE_250: typing.ClassVar[mjtFontScale]  # value = <mjtFontScale.mjFONTSCALE_250: 250>
+    mjFONTSCALE_300: typing.ClassVar[mjtFontScale]  # value = <mjtFontScale.mjFONTSCALE_300: 300>
+    mjFONTSCALE_50: typing.ClassVar[mjtFontScale]  # value = <mjtFontScale.mjFONTSCALE_50: 50>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtFrame:
+    """
+    Members:
+    
+      mjFRAME_NONE
+    
+      mjFRAME_BODY
+    
+      mjFRAME_GEOM
+    
+      mjFRAME_SITE
+    
+      mjFRAME_CAMERA
+    
+      mjFRAME_LIGHT
+    
+      mjFRAME_CONTACT
+    
+      mjFRAME_WORLD
+    
+      mjNFRAME
+    """
+    __members__: typing.ClassVar[dict[str, mjtFrame]]  # value = {'mjFRAME_NONE': <mjtFrame.mjFRAME_NONE: 0>, 'mjFRAME_BODY': <mjtFrame.mjFRAME_BODY: 1>, 'mjFRAME_GEOM': <mjtFrame.mjFRAME_GEOM: 2>, 'mjFRAME_SITE': <mjtFrame.mjFRAME_SITE: 3>, 'mjFRAME_CAMERA': <mjtFrame.mjFRAME_CAMERA: 4>, 'mjFRAME_LIGHT': <mjtFrame.mjFRAME_LIGHT: 5>, 'mjFRAME_CONTACT': <mjtFrame.mjFRAME_CONTACT: 6>, 'mjFRAME_WORLD': <mjtFrame.mjFRAME_WORLD: 7>, 'mjNFRAME': <mjtFrame.mjNFRAME: 8>}
+    mjFRAME_BODY: typing.ClassVar[mjtFrame]  # value = <mjtFrame.mjFRAME_BODY: 1>
+    mjFRAME_CAMERA: typing.ClassVar[mjtFrame]  # value = <mjtFrame.mjFRAME_CAMERA: 4>
+    mjFRAME_CONTACT: typing.ClassVar[mjtFrame]  # value = <mjtFrame.mjFRAME_CONTACT: 6>
+    mjFRAME_GEOM: typing.ClassVar[mjtFrame]  # value = <mjtFrame.mjFRAME_GEOM: 2>
+    mjFRAME_LIGHT: typing.ClassVar[mjtFrame]  # value = <mjtFrame.mjFRAME_LIGHT: 5>
+    mjFRAME_NONE: typing.ClassVar[mjtFrame]  # value = <mjtFrame.mjFRAME_NONE: 0>
+    mjFRAME_SITE: typing.ClassVar[mjtFrame]  # value = <mjtFrame.mjFRAME_SITE: 3>
+    mjFRAME_WORLD: typing.ClassVar[mjtFrame]  # value = <mjtFrame.mjFRAME_WORLD: 7>
+    mjNFRAME: typing.ClassVar[mjtFrame]  # value = <mjtFrame.mjNFRAME: 8>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtFramebuffer:
+    """
+    Members:
+    
+      mjFB_WINDOW
+    
+      mjFB_OFFSCREEN
+    """
+    __members__: typing.ClassVar[dict[str, mjtFramebuffer]]  # value = {'mjFB_WINDOW': <mjtFramebuffer.mjFB_WINDOW: 0>, 'mjFB_OFFSCREEN': <mjtFramebuffer.mjFB_OFFSCREEN: 1>}
+    mjFB_OFFSCREEN: typing.ClassVar[mjtFramebuffer]  # value = <mjtFramebuffer.mjFB_OFFSCREEN: 1>
+    mjFB_WINDOW: typing.ClassVar[mjtFramebuffer]  # value = <mjtFramebuffer.mjFB_WINDOW: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtGain:
+    """
+    Members:
+    
+      mjGAIN_FIXED
+    
+      mjGAIN_AFFINE
+    
+      mjGAIN_MUSCLE
+    
+      mjGAIN_DCMOTOR
+    
+      mjGAIN_SO3
+    
+      mjGAIN_USER
+    """
+    __members__: typing.ClassVar[dict[str, mjtGain]]  # value = {'mjGAIN_FIXED': <mjtGain.mjGAIN_FIXED: 0>, 'mjGAIN_AFFINE': <mjtGain.mjGAIN_AFFINE: 1>, 'mjGAIN_MUSCLE': <mjtGain.mjGAIN_MUSCLE: 2>, 'mjGAIN_DCMOTOR': <mjtGain.mjGAIN_DCMOTOR: 3>, 'mjGAIN_SO3': <mjtGain.mjGAIN_SO3: 4>, 'mjGAIN_USER': <mjtGain.mjGAIN_USER: 5>}
+    mjGAIN_AFFINE: typing.ClassVar[mjtGain]  # value = <mjtGain.mjGAIN_AFFINE: 1>
+    mjGAIN_DCMOTOR: typing.ClassVar[mjtGain]  # value = <mjtGain.mjGAIN_DCMOTOR: 3>
+    mjGAIN_FIXED: typing.ClassVar[mjtGain]  # value = <mjtGain.mjGAIN_FIXED: 0>
+    mjGAIN_MUSCLE: typing.ClassVar[mjtGain]  # value = <mjtGain.mjGAIN_MUSCLE: 2>
+    mjGAIN_SO3: typing.ClassVar[mjtGain]  # value = <mjtGain.mjGAIN_SO3: 4>
+    mjGAIN_USER: typing.ClassVar[mjtGain]  # value = <mjtGain.mjGAIN_USER: 5>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtGeom:
+    """
+    Members:
+    
+      mjGEOM_PLANE
+    
+      mjGEOM_HFIELD
+    
+      mjGEOM_SPHERE
+    
+      mjGEOM_CAPSULE
+    
+      mjGEOM_ELLIPSOID
+    
+      mjGEOM_CYLINDER
+    
+      mjGEOM_BOX
+    
+      mjGEOM_MESH
+    
+      mjGEOM_SDF
+    
+      mjNGEOMTYPES
+    
+      mjGEOM_ARROW
+    
+      mjGEOM_ARROW1
+    
+      mjGEOM_ARROW2
+    
+      mjGEOM_LINE
+    
+      mjGEOM_LINEBOX
+    
+      mjGEOM_FLEX
+    
+      mjGEOM_SKIN
+    
+      mjGEOM_LABEL
+    
+      mjGEOM_TRIANGLE
+    
+      mjGEOM_NONE
+    """
+    __members__: typing.ClassVar[dict[str, mjtGeom]]  # value = {'mjGEOM_PLANE': <mjtGeom.mjGEOM_PLANE: 0>, 'mjGEOM_HFIELD': <mjtGeom.mjGEOM_HFIELD: 1>, 'mjGEOM_SPHERE': <mjtGeom.mjGEOM_SPHERE: 2>, 'mjGEOM_CAPSULE': <mjtGeom.mjGEOM_CAPSULE: 3>, 'mjGEOM_ELLIPSOID': <mjtGeom.mjGEOM_ELLIPSOID: 4>, 'mjGEOM_CYLINDER': <mjtGeom.mjGEOM_CYLINDER: 5>, 'mjGEOM_BOX': <mjtGeom.mjGEOM_BOX: 6>, 'mjGEOM_MESH': <mjtGeom.mjGEOM_MESH: 7>, 'mjGEOM_SDF': <mjtGeom.mjGEOM_SDF: 8>, 'mjNGEOMTYPES': <mjtGeom.mjNGEOMTYPES: 9>, 'mjGEOM_ARROW': <mjtGeom.mjGEOM_ARROW: 100>, 'mjGEOM_ARROW1': <mjtGeom.mjGEOM_ARROW1: 101>, 'mjGEOM_ARROW2': <mjtGeom.mjGEOM_ARROW2: 102>, 'mjGEOM_LINE': <mjtGeom.mjGEOM_LINE: 103>, 'mjGEOM_LINEBOX': <mjtGeom.mjGEOM_LINEBOX: 104>, 'mjGEOM_FLEX': <mjtGeom.mjGEOM_FLEX: 105>, 'mjGEOM_SKIN': <mjtGeom.mjGEOM_SKIN: 106>, 'mjGEOM_LABEL': <mjtGeom.mjGEOM_LABEL: 107>, 'mjGEOM_TRIANGLE': <mjtGeom.mjGEOM_TRIANGLE: 108>, 'mjGEOM_NONE': <mjtGeom.mjGEOM_NONE: 1001>}
+    mjGEOM_ARROW: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_ARROW: 100>
+    mjGEOM_ARROW1: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_ARROW1: 101>
+    mjGEOM_ARROW2: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_ARROW2: 102>
+    mjGEOM_BOX: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_BOX: 6>
+    mjGEOM_CAPSULE: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_CAPSULE: 3>
+    mjGEOM_CYLINDER: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_CYLINDER: 5>
+    mjGEOM_ELLIPSOID: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_ELLIPSOID: 4>
+    mjGEOM_FLEX: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_FLEX: 105>
+    mjGEOM_HFIELD: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_HFIELD: 1>
+    mjGEOM_LABEL: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_LABEL: 107>
+    mjGEOM_LINE: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_LINE: 103>
+    mjGEOM_LINEBOX: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_LINEBOX: 104>
+    mjGEOM_MESH: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_MESH: 7>
+    mjGEOM_NONE: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_NONE: 1001>
+    mjGEOM_PLANE: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_PLANE: 0>
+    mjGEOM_SDF: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_SDF: 8>
+    mjGEOM_SKIN: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_SKIN: 106>
+    mjGEOM_SPHERE: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_SPHERE: 2>
+    mjGEOM_TRIANGLE: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjGEOM_TRIANGLE: 108>
+    mjNGEOMTYPES: typing.ClassVar[mjtGeom]  # value = <mjtGeom.mjNGEOMTYPES: 9>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtGeomInertia:
+    """
+    Members:
+    
+      mjINERTIA_VOLUME
+    
+      mjINERTIA_SHELL
+    """
+    __members__: typing.ClassVar[dict[str, mjtGeomInertia]]  # value = {'mjINERTIA_VOLUME': <mjtGeomInertia.mjINERTIA_VOLUME: 0>, 'mjINERTIA_SHELL': <mjtGeomInertia.mjINERTIA_SHELL: 1>}
+    mjINERTIA_SHELL: typing.ClassVar[mjtGeomInertia]  # value = <mjtGeomInertia.mjINERTIA_SHELL: 1>
+    mjINERTIA_VOLUME: typing.ClassVar[mjtGeomInertia]  # value = <mjtGeomInertia.mjINERTIA_VOLUME: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtGridPos:
+    """
+    Members:
+    
+      mjGRID_TOPLEFT
+    
+      mjGRID_TOPRIGHT
+    
+      mjGRID_BOTTOMLEFT
+    
+      mjGRID_BOTTOMRIGHT
+    
+      mjGRID_TOP
+    
+      mjGRID_BOTTOM
+    
+      mjGRID_LEFT
+    
+      mjGRID_RIGHT
+    """
+    __members__: typing.ClassVar[dict[str, mjtGridPos]]  # value = {'mjGRID_TOPLEFT': <mjtGridPos.mjGRID_TOPLEFT: 0>, 'mjGRID_TOPRIGHT': <mjtGridPos.mjGRID_TOPRIGHT: 1>, 'mjGRID_BOTTOMLEFT': <mjtGridPos.mjGRID_BOTTOMLEFT: 2>, 'mjGRID_BOTTOMRIGHT': <mjtGridPos.mjGRID_BOTTOMRIGHT: 3>, 'mjGRID_TOP': <mjtGridPos.mjGRID_TOP: 4>, 'mjGRID_BOTTOM': <mjtGridPos.mjGRID_BOTTOM: 5>, 'mjGRID_LEFT': <mjtGridPos.mjGRID_LEFT: 6>, 'mjGRID_RIGHT': <mjtGridPos.mjGRID_RIGHT: 7>}
+    mjGRID_BOTTOM: typing.ClassVar[mjtGridPos]  # value = <mjtGridPos.mjGRID_BOTTOM: 5>
+    mjGRID_BOTTOMLEFT: typing.ClassVar[mjtGridPos]  # value = <mjtGridPos.mjGRID_BOTTOMLEFT: 2>
+    mjGRID_BOTTOMRIGHT: typing.ClassVar[mjtGridPos]  # value = <mjtGridPos.mjGRID_BOTTOMRIGHT: 3>
+    mjGRID_LEFT: typing.ClassVar[mjtGridPos]  # value = <mjtGridPos.mjGRID_LEFT: 6>
+    mjGRID_RIGHT: typing.ClassVar[mjtGridPos]  # value = <mjtGridPos.mjGRID_RIGHT: 7>
+    mjGRID_TOP: typing.ClassVar[mjtGridPos]  # value = <mjtGridPos.mjGRID_TOP: 4>
+    mjGRID_TOPLEFT: typing.ClassVar[mjtGridPos]  # value = <mjtGridPos.mjGRID_TOPLEFT: 0>
+    mjGRID_TOPRIGHT: typing.ClassVar[mjtGridPos]  # value = <mjtGridPos.mjGRID_TOPRIGHT: 1>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtInertiaFromGeom:
+    """
+    Members:
+    
+      mjINERTIAFROMGEOM_FALSE
+    
+      mjINERTIAFROMGEOM_TRUE
+    
+      mjINERTIAFROMGEOM_AUTO
+    """
+    __members__: typing.ClassVar[dict[str, mjtInertiaFromGeom]]  # value = {'mjINERTIAFROMGEOM_FALSE': <mjtInertiaFromGeom.mjINERTIAFROMGEOM_FALSE: 0>, 'mjINERTIAFROMGEOM_TRUE': <mjtInertiaFromGeom.mjINERTIAFROMGEOM_TRUE: 1>, 'mjINERTIAFROMGEOM_AUTO': <mjtInertiaFromGeom.mjINERTIAFROMGEOM_AUTO: 2>}
+    mjINERTIAFROMGEOM_AUTO: typing.ClassVar[mjtInertiaFromGeom]  # value = <mjtInertiaFromGeom.mjINERTIAFROMGEOM_AUTO: 2>
+    mjINERTIAFROMGEOM_FALSE: typing.ClassVar[mjtInertiaFromGeom]  # value = <mjtInertiaFromGeom.mjINERTIAFROMGEOM_FALSE: 0>
+    mjINERTIAFROMGEOM_TRUE: typing.ClassVar[mjtInertiaFromGeom]  # value = <mjtInertiaFromGeom.mjINERTIAFROMGEOM_TRUE: 1>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtIntegrator:
+    """
+    Members:
+    
+      mjINT_EULER
+    
+      mjINT_RK4
+    
+      mjINT_IMPLICIT
+    
+      mjINT_IMPLICITFAST
+    """
+    __members__: typing.ClassVar[dict[str, mjtIntegrator]]  # value = {'mjINT_EULER': <mjtIntegrator.mjINT_EULER: 0>, 'mjINT_RK4': <mjtIntegrator.mjINT_RK4: 1>, 'mjINT_IMPLICIT': <mjtIntegrator.mjINT_IMPLICIT: 2>, 'mjINT_IMPLICITFAST': <mjtIntegrator.mjINT_IMPLICITFAST: 3>}
+    mjINT_EULER: typing.ClassVar[mjtIntegrator]  # value = <mjtIntegrator.mjINT_EULER: 0>
+    mjINT_IMPLICIT: typing.ClassVar[mjtIntegrator]  # value = <mjtIntegrator.mjINT_IMPLICIT: 2>
+    mjINT_IMPLICITFAST: typing.ClassVar[mjtIntegrator]  # value = <mjtIntegrator.mjINT_IMPLICITFAST: 3>
+    mjINT_RK4: typing.ClassVar[mjtIntegrator]  # value = <mjtIntegrator.mjINT_RK4: 1>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtItem:
+    """
+    Members:
+    
+      mjITEM_END
+    
+      mjITEM_SECTION
+    
+      mjITEM_SEPARATOR
+    
+      mjITEM_STATIC
+    
+      mjITEM_BUTTON
+    
+      mjITEM_CHECKINT
+    
+      mjITEM_CHECKBYTE
+    
+      mjITEM_RADIO
+    
+      mjITEM_RADIOLINE
+    
+      mjITEM_SELECT
+    
+      mjITEM_SLIDERINT
+    
+      mjITEM_SLIDERNUM
+    
+      mjITEM_EDITINT
+    
+      mjITEM_EDITNUM
+    
+      mjITEM_EDITFLOAT
+    
+      mjITEM_EDITTXT
+    
+      mjNITEM
+    """
+    __members__: typing.ClassVar[dict[str, mjtItem]]  # value = {'mjITEM_END': <mjtItem.mjITEM_END: -2>, 'mjITEM_SECTION': <mjtItem.mjITEM_SECTION: -1>, 'mjITEM_SEPARATOR': <mjtItem.mjITEM_SEPARATOR: 0>, 'mjITEM_STATIC': <mjtItem.mjITEM_STATIC: 1>, 'mjITEM_BUTTON': <mjtItem.mjITEM_BUTTON: 2>, 'mjITEM_CHECKINT': <mjtItem.mjITEM_CHECKINT: 3>, 'mjITEM_CHECKBYTE': <mjtItem.mjITEM_CHECKBYTE: 4>, 'mjITEM_RADIO': <mjtItem.mjITEM_RADIO: 5>, 'mjITEM_RADIOLINE': <mjtItem.mjITEM_RADIOLINE: 6>, 'mjITEM_SELECT': <mjtItem.mjITEM_SELECT: 7>, 'mjITEM_SLIDERINT': <mjtItem.mjITEM_SLIDERINT: 8>, 'mjITEM_SLIDERNUM': <mjtItem.mjITEM_SLIDERNUM: 9>, 'mjITEM_EDITINT': <mjtItem.mjITEM_EDITINT: 10>, 'mjITEM_EDITNUM': <mjtItem.mjITEM_EDITNUM: 11>, 'mjITEM_EDITFLOAT': <mjtItem.mjITEM_EDITFLOAT: 12>, 'mjITEM_EDITTXT': <mjtItem.mjITEM_EDITTXT: 13>, 'mjNITEM': <mjtItem.mjNITEM: 14>}
+    mjITEM_BUTTON: typing.ClassVar[mjtItem]  # value = <mjtItem.mjITEM_BUTTON: 2>
+    mjITEM_CHECKBYTE: typing.ClassVar[mjtItem]  # value = <mjtItem.mjITEM_CHECKBYTE: 4>
+    mjITEM_CHECKINT: typing.ClassVar[mjtItem]  # value = <mjtItem.mjITEM_CHECKINT: 3>
+    mjITEM_EDITFLOAT: typing.ClassVar[mjtItem]  # value = <mjtItem.mjITEM_EDITFLOAT: 12>
+    mjITEM_EDITINT: typing.ClassVar[mjtItem]  # value = <mjtItem.mjITEM_EDITINT: 10>
+    mjITEM_EDITNUM: typing.ClassVar[mjtItem]  # value = <mjtItem.mjITEM_EDITNUM: 11>
+    mjITEM_EDITTXT: typing.ClassVar[mjtItem]  # value = <mjtItem.mjITEM_EDITTXT: 13>
+    mjITEM_END: typing.ClassVar[mjtItem]  # value = <mjtItem.mjITEM_END: -2>
+    mjITEM_RADIO: typing.ClassVar[mjtItem]  # value = <mjtItem.mjITEM_RADIO: 5>
+    mjITEM_RADIOLINE: typing.ClassVar[mjtItem]  # value = <mjtItem.mjITEM_RADIOLINE: 6>
+    mjITEM_SECTION: typing.ClassVar[mjtItem]  # value = <mjtItem.mjITEM_SECTION: -1>
+    mjITEM_SELECT: typing.ClassVar[mjtItem]  # value = <mjtItem.mjITEM_SELECT: 7>
+    mjITEM_SEPARATOR: typing.ClassVar[mjtItem]  # value = <mjtItem.mjITEM_SEPARATOR: 0>
+    mjITEM_SLIDERINT: typing.ClassVar[mjtItem]  # value = <mjtItem.mjITEM_SLIDERINT: 8>
+    mjITEM_SLIDERNUM: typing.ClassVar[mjtItem]  # value = <mjtItem.mjITEM_SLIDERNUM: 9>
+    mjITEM_STATIC: typing.ClassVar[mjtItem]  # value = <mjtItem.mjITEM_STATIC: 1>
+    mjNITEM: typing.ClassVar[mjtItem]  # value = <mjtItem.mjNITEM: 14>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtJacobian:
+    """
+    Members:
+    
+      mjJAC_DENSE
+    
+      mjJAC_SPARSE
+    
+      mjJAC_AUTO
+    """
+    __members__: typing.ClassVar[dict[str, mjtJacobian]]  # value = {'mjJAC_DENSE': <mjtJacobian.mjJAC_DENSE: 0>, 'mjJAC_SPARSE': <mjtJacobian.mjJAC_SPARSE: 1>, 'mjJAC_AUTO': <mjtJacobian.mjJAC_AUTO: 2>}
+    mjJAC_AUTO: typing.ClassVar[mjtJacobian]  # value = <mjtJacobian.mjJAC_AUTO: 2>
+    mjJAC_DENSE: typing.ClassVar[mjtJacobian]  # value = <mjtJacobian.mjJAC_DENSE: 0>
+    mjJAC_SPARSE: typing.ClassVar[mjtJacobian]  # value = <mjtJacobian.mjJAC_SPARSE: 1>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtJoint:
+    """
+    Members:
+    
+      mjJNT_FREE
+    
+      mjJNT_BALL
+    
+      mjJNT_SLIDE
+    
+      mjJNT_HINGE
+    """
+    __members__: typing.ClassVar[dict[str, mjtJoint]]  # value = {'mjJNT_FREE': <mjtJoint.mjJNT_FREE: 0>, 'mjJNT_BALL': <mjtJoint.mjJNT_BALL: 1>, 'mjJNT_SLIDE': <mjtJoint.mjJNT_SLIDE: 2>, 'mjJNT_HINGE': <mjtJoint.mjJNT_HINGE: 3>}
+    mjJNT_BALL: typing.ClassVar[mjtJoint]  # value = <mjtJoint.mjJNT_BALL: 1>
+    mjJNT_FREE: typing.ClassVar[mjtJoint]  # value = <mjtJoint.mjJNT_FREE: 0>
+    mjJNT_HINGE: typing.ClassVar[mjtJoint]  # value = <mjtJoint.mjJNT_HINGE: 3>
+    mjJNT_SLIDE: typing.ClassVar[mjtJoint]  # value = <mjtJoint.mjJNT_SLIDE: 2>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtLRMode:
+    """
+    Members:
+    
+      mjLRMODE_NONE
+    
+      mjLRMODE_MUSCLE
+    
+      mjLRMODE_MUSCLEUSER
+    
+      mjLRMODE_ALL
+    """
+    __members__: typing.ClassVar[dict[str, mjtLRMode]]  # value = {'mjLRMODE_NONE': <mjtLRMode.mjLRMODE_NONE: 0>, 'mjLRMODE_MUSCLE': <mjtLRMode.mjLRMODE_MUSCLE: 1>, 'mjLRMODE_MUSCLEUSER': <mjtLRMode.mjLRMODE_MUSCLEUSER: 2>, 'mjLRMODE_ALL': <mjtLRMode.mjLRMODE_ALL: 3>}
+    mjLRMODE_ALL: typing.ClassVar[mjtLRMode]  # value = <mjtLRMode.mjLRMODE_ALL: 3>
+    mjLRMODE_MUSCLE: typing.ClassVar[mjtLRMode]  # value = <mjtLRMode.mjLRMODE_MUSCLE: 1>
+    mjLRMODE_MUSCLEUSER: typing.ClassVar[mjtLRMode]  # value = <mjtLRMode.mjLRMODE_MUSCLEUSER: 2>
+    mjLRMODE_NONE: typing.ClassVar[mjtLRMode]  # value = <mjtLRMode.mjLRMODE_NONE: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtLabel:
+    """
+    Members:
+    
+      mjLABEL_NONE
+    
+      mjLABEL_BODY
+    
+      mjLABEL_JOINT
+    
+      mjLABEL_GEOM
+    
+      mjLABEL_SITE
+    
+      mjLABEL_CAMERA
+    
+      mjLABEL_LIGHT
+    
+      mjLABEL_TENDON
+    
+      mjLABEL_ACTUATOR
+    
+      mjLABEL_CONSTRAINT
+    
+      mjLABEL_FLEX
+    
+      mjLABEL_SKIN
+    
+      mjLABEL_SELECTION
+    
+      mjLABEL_SELPNT
+    
+      mjLABEL_CONTACTPOINT
+    
+      mjLABEL_CONTACTFORCE
+    
+      mjLABEL_ISLAND
+    
+      mjNLABEL
+    """
+    __members__: typing.ClassVar[dict[str, mjtLabel]]  # value = {'mjLABEL_NONE': <mjtLabel.mjLABEL_NONE: 0>, 'mjLABEL_BODY': <mjtLabel.mjLABEL_BODY: 1>, 'mjLABEL_JOINT': <mjtLabel.mjLABEL_JOINT: 2>, 'mjLABEL_GEOM': <mjtLabel.mjLABEL_GEOM: 3>, 'mjLABEL_SITE': <mjtLabel.mjLABEL_SITE: 4>, 'mjLABEL_CAMERA': <mjtLabel.mjLABEL_CAMERA: 5>, 'mjLABEL_LIGHT': <mjtLabel.mjLABEL_LIGHT: 6>, 'mjLABEL_TENDON': <mjtLabel.mjLABEL_TENDON: 7>, 'mjLABEL_ACTUATOR': <mjtLabel.mjLABEL_ACTUATOR: 8>, 'mjLABEL_CONSTRAINT': <mjtLabel.mjLABEL_CONSTRAINT: 9>, 'mjLABEL_FLEX': <mjtLabel.mjLABEL_FLEX: 10>, 'mjLABEL_SKIN': <mjtLabel.mjLABEL_SKIN: 11>, 'mjLABEL_SELECTION': <mjtLabel.mjLABEL_SELECTION: 12>, 'mjLABEL_SELPNT': <mjtLabel.mjLABEL_SELPNT: 13>, 'mjLABEL_CONTACTPOINT': <mjtLabel.mjLABEL_CONTACTPOINT: 14>, 'mjLABEL_CONTACTFORCE': <mjtLabel.mjLABEL_CONTACTFORCE: 15>, 'mjLABEL_ISLAND': <mjtLabel.mjLABEL_ISLAND: 16>, 'mjNLABEL': <mjtLabel.mjNLABEL: 17>}
+    mjLABEL_ACTUATOR: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjLABEL_ACTUATOR: 8>
+    mjLABEL_BODY: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjLABEL_BODY: 1>
+    mjLABEL_CAMERA: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjLABEL_CAMERA: 5>
+    mjLABEL_CONSTRAINT: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjLABEL_CONSTRAINT: 9>
+    mjLABEL_CONTACTFORCE: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjLABEL_CONTACTFORCE: 15>
+    mjLABEL_CONTACTPOINT: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjLABEL_CONTACTPOINT: 14>
+    mjLABEL_FLEX: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjLABEL_FLEX: 10>
+    mjLABEL_GEOM: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjLABEL_GEOM: 3>
+    mjLABEL_ISLAND: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjLABEL_ISLAND: 16>
+    mjLABEL_JOINT: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjLABEL_JOINT: 2>
+    mjLABEL_LIGHT: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjLABEL_LIGHT: 6>
+    mjLABEL_NONE: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjLABEL_NONE: 0>
+    mjLABEL_SELECTION: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjLABEL_SELECTION: 12>
+    mjLABEL_SELPNT: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjLABEL_SELPNT: 13>
+    mjLABEL_SITE: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjLABEL_SITE: 4>
+    mjLABEL_SKIN: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjLABEL_SKIN: 11>
+    mjLABEL_TENDON: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjLABEL_TENDON: 7>
+    mjNLABEL: typing.ClassVar[mjtLabel]  # value = <mjtLabel.mjNLABEL: 17>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtLightType:
+    """
+    Members:
+    
+      mjLIGHT_SPOT
+    
+      mjLIGHT_DIRECTIONAL
+    
+      mjLIGHT_POINT
+    
+      mjLIGHT_IMAGE
+    """
+    __members__: typing.ClassVar[dict[str, mjtLightType]]  # value = {'mjLIGHT_SPOT': <mjtLightType.mjLIGHT_SPOT: 0>, 'mjLIGHT_DIRECTIONAL': <mjtLightType.mjLIGHT_DIRECTIONAL: 1>, 'mjLIGHT_POINT': <mjtLightType.mjLIGHT_POINT: 2>, 'mjLIGHT_IMAGE': <mjtLightType.mjLIGHT_IMAGE: 3>}
+    mjLIGHT_DIRECTIONAL: typing.ClassVar[mjtLightType]  # value = <mjtLightType.mjLIGHT_DIRECTIONAL: 1>
+    mjLIGHT_IMAGE: typing.ClassVar[mjtLightType]  # value = <mjtLightType.mjLIGHT_IMAGE: 3>
+    mjLIGHT_POINT: typing.ClassVar[mjtLightType]  # value = <mjtLightType.mjLIGHT_POINT: 2>
+    mjLIGHT_SPOT: typing.ClassVar[mjtLightType]  # value = <mjtLightType.mjLIGHT_SPOT: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtLimited:
+    """
+    Members:
+    
+      mjLIMITED_FALSE
+    
+      mjLIMITED_TRUE
+    
+      mjLIMITED_AUTO
+    """
+    __members__: typing.ClassVar[dict[str, mjtLimited]]  # value = {'mjLIMITED_FALSE': <mjtLimited.mjLIMITED_FALSE: 0>, 'mjLIMITED_TRUE': <mjtLimited.mjLIMITED_TRUE: 1>, 'mjLIMITED_AUTO': <mjtLimited.mjLIMITED_AUTO: 2>}
+    mjLIMITED_AUTO: typing.ClassVar[mjtLimited]  # value = <mjtLimited.mjLIMITED_AUTO: 2>
+    mjLIMITED_FALSE: typing.ClassVar[mjtLimited]  # value = <mjtLimited.mjLIMITED_FALSE: 0>
+    mjLIMITED_TRUE: typing.ClassVar[mjtLimited]  # value = <mjtLimited.mjLIMITED_TRUE: 1>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtLogLevel:
+    """
+    Members:
+    
+      mjLOG_DEBUG
+    
+      mjLOG_INFO
+    
+      mjLOG_WARNING
+    
+      mjLOG_ERROR
+    """
+    __members__: typing.ClassVar[dict[str, mjtLogLevel]]  # value = {'mjLOG_DEBUG': <mjtLogLevel.mjLOG_DEBUG: 0>, 'mjLOG_INFO': <mjtLogLevel.mjLOG_INFO: 1>, 'mjLOG_WARNING': <mjtLogLevel.mjLOG_WARNING: 2>, 'mjLOG_ERROR': <mjtLogLevel.mjLOG_ERROR: 3>}
+    mjLOG_DEBUG: typing.ClassVar[mjtLogLevel]  # value = <mjtLogLevel.mjLOG_DEBUG: 0>
+    mjLOG_ERROR: typing.ClassVar[mjtLogLevel]  # value = <mjtLogLevel.mjLOG_ERROR: 3>
+    mjLOG_INFO: typing.ClassVar[mjtLogLevel]  # value = <mjtLogLevel.mjLOG_INFO: 1>
+    mjLOG_WARNING: typing.ClassVar[mjtLogLevel]  # value = <mjtLogLevel.mjLOG_WARNING: 2>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtLogTopic:
+    """
+    Members:
+    
+      mjTOPIC_NONE
+    
+      mjTOPIC_TIME_STP
+    
+      mjTOPIC_TIME_CMP
+    
+      mjTOPIC_SLEEP
+    
+      mjNTOPIC
+    """
+    __members__: typing.ClassVar[dict[str, mjtLogTopic]]  # value = {'mjTOPIC_NONE': <mjtLogTopic.mjTOPIC_NONE: 0>, 'mjTOPIC_TIME_STP': <mjtLogTopic.mjTOPIC_TIME_STP: 1>, 'mjTOPIC_TIME_CMP': <mjtLogTopic.mjTOPIC_TIME_CMP: 2>, 'mjTOPIC_SLEEP': <mjtLogTopic.mjTOPIC_SLEEP: 3>, 'mjNTOPIC': <mjtLogTopic.mjTOPIC_SLEEP: 3>}
+    mjNTOPIC: typing.ClassVar[mjtLogTopic]  # value = <mjtLogTopic.mjTOPIC_SLEEP: 3>
+    mjTOPIC_NONE: typing.ClassVar[mjtLogTopic]  # value = <mjtLogTopic.mjTOPIC_NONE: 0>
+    mjTOPIC_SLEEP: typing.ClassVar[mjtLogTopic]  # value = <mjtLogTopic.mjTOPIC_SLEEP: 3>
+    mjTOPIC_TIME_CMP: typing.ClassVar[mjtLogTopic]  # value = <mjtLogTopic.mjTOPIC_TIME_CMP: 2>
+    mjTOPIC_TIME_STP: typing.ClassVar[mjtLogTopic]  # value = <mjtLogTopic.mjTOPIC_TIME_STP: 1>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtMark:
+    """
+    Members:
+    
+      mjMARK_NONE
+    
+      mjMARK_EDGE
+    
+      mjMARK_CROSS
+    
+      mjMARK_RANDOM
+    """
+    __members__: typing.ClassVar[dict[str, mjtMark]]  # value = {'mjMARK_NONE': <mjtMark.mjMARK_NONE: 0>, 'mjMARK_EDGE': <mjtMark.mjMARK_EDGE: 1>, 'mjMARK_CROSS': <mjtMark.mjMARK_CROSS: 2>, 'mjMARK_RANDOM': <mjtMark.mjMARK_RANDOM: 3>}
+    mjMARK_CROSS: typing.ClassVar[mjtMark]  # value = <mjtMark.mjMARK_CROSS: 2>
+    mjMARK_EDGE: typing.ClassVar[mjtMark]  # value = <mjtMark.mjMARK_EDGE: 1>
+    mjMARK_NONE: typing.ClassVar[mjtMark]  # value = <mjtMark.mjMARK_NONE: 0>
+    mjMARK_RANDOM: typing.ClassVar[mjtMark]  # value = <mjtMark.mjMARK_RANDOM: 3>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtMeshBuiltin:
+    """
+    Members:
+    
+      mjMESH_BUILTIN_NONE
+    
+      mjMESH_BUILTIN_SPHERE
+    
+      mjMESH_BUILTIN_HEMISPHERE
+    
+      mjMESH_BUILTIN_CONE
+    
+      mjMESH_BUILTIN_SUPERSPHERE
+    
+      mjMESH_BUILTIN_SUPERTORUS
+    
+      mjMESH_BUILTIN_WEDGE
+    
+      mjMESH_BUILTIN_PLATE
+    """
+    __members__: typing.ClassVar[dict[str, mjtMeshBuiltin]]  # value = {'mjMESH_BUILTIN_NONE': <mjtMeshBuiltin.mjMESH_BUILTIN_NONE: 0>, 'mjMESH_BUILTIN_SPHERE': <mjtMeshBuiltin.mjMESH_BUILTIN_SPHERE: 1>, 'mjMESH_BUILTIN_HEMISPHERE': <mjtMeshBuiltin.mjMESH_BUILTIN_HEMISPHERE: 2>, 'mjMESH_BUILTIN_CONE': <mjtMeshBuiltin.mjMESH_BUILTIN_CONE: 3>, 'mjMESH_BUILTIN_SUPERSPHERE': <mjtMeshBuiltin.mjMESH_BUILTIN_SUPERSPHERE: 4>, 'mjMESH_BUILTIN_SUPERTORUS': <mjtMeshBuiltin.mjMESH_BUILTIN_SUPERTORUS: 5>, 'mjMESH_BUILTIN_WEDGE': <mjtMeshBuiltin.mjMESH_BUILTIN_WEDGE: 6>, 'mjMESH_BUILTIN_PLATE': <mjtMeshBuiltin.mjMESH_BUILTIN_PLATE: 7>}
+    mjMESH_BUILTIN_CONE: typing.ClassVar[mjtMeshBuiltin]  # value = <mjtMeshBuiltin.mjMESH_BUILTIN_CONE: 3>
+    mjMESH_BUILTIN_HEMISPHERE: typing.ClassVar[mjtMeshBuiltin]  # value = <mjtMeshBuiltin.mjMESH_BUILTIN_HEMISPHERE: 2>
+    mjMESH_BUILTIN_NONE: typing.ClassVar[mjtMeshBuiltin]  # value = <mjtMeshBuiltin.mjMESH_BUILTIN_NONE: 0>
+    mjMESH_BUILTIN_PLATE: typing.ClassVar[mjtMeshBuiltin]  # value = <mjtMeshBuiltin.mjMESH_BUILTIN_PLATE: 7>
+    mjMESH_BUILTIN_SPHERE: typing.ClassVar[mjtMeshBuiltin]  # value = <mjtMeshBuiltin.mjMESH_BUILTIN_SPHERE: 1>
+    mjMESH_BUILTIN_SUPERSPHERE: typing.ClassVar[mjtMeshBuiltin]  # value = <mjtMeshBuiltin.mjMESH_BUILTIN_SUPERSPHERE: 4>
+    mjMESH_BUILTIN_SUPERTORUS: typing.ClassVar[mjtMeshBuiltin]  # value = <mjtMeshBuiltin.mjMESH_BUILTIN_SUPERTORUS: 5>
+    mjMESH_BUILTIN_WEDGE: typing.ClassVar[mjtMeshBuiltin]  # value = <mjtMeshBuiltin.mjMESH_BUILTIN_WEDGE: 6>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtMeshInertia:
+    """
+    Members:
+    
+      mjMESH_INERTIA_CONVEX
+    
+      mjMESH_INERTIA_EXACT
+    
+      mjMESH_INERTIA_LEGACY
+    
+      mjMESH_INERTIA_SHELL
+    """
+    __members__: typing.ClassVar[dict[str, mjtMeshInertia]]  # value = {'mjMESH_INERTIA_CONVEX': <mjtMeshInertia.mjMESH_INERTIA_CONVEX: 0>, 'mjMESH_INERTIA_EXACT': <mjtMeshInertia.mjMESH_INERTIA_EXACT: 1>, 'mjMESH_INERTIA_LEGACY': <mjtMeshInertia.mjMESH_INERTIA_LEGACY: 2>, 'mjMESH_INERTIA_SHELL': <mjtMeshInertia.mjMESH_INERTIA_SHELL: 3>}
+    mjMESH_INERTIA_CONVEX: typing.ClassVar[mjtMeshInertia]  # value = <mjtMeshInertia.mjMESH_INERTIA_CONVEX: 0>
+    mjMESH_INERTIA_EXACT: typing.ClassVar[mjtMeshInertia]  # value = <mjtMeshInertia.mjMESH_INERTIA_EXACT: 1>
+    mjMESH_INERTIA_LEGACY: typing.ClassVar[mjtMeshInertia]  # value = <mjtMeshInertia.mjMESH_INERTIA_LEGACY: 2>
+    mjMESH_INERTIA_SHELL: typing.ClassVar[mjtMeshInertia]  # value = <mjtMeshInertia.mjMESH_INERTIA_SHELL: 3>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtMouse:
+    """
+    Members:
+    
+      mjMOUSE_NONE
+    
+      mjMOUSE_ROTATE_V
+    
+      mjMOUSE_ROTATE_H
+    
+      mjMOUSE_MOVE_V
+    
+      mjMOUSE_MOVE_H
+    
+      mjMOUSE_ZOOM
+    
+      mjMOUSE_MOVE_V_REL
+    
+      mjMOUSE_MOVE_H_REL
+    
+      mjMOUSE_TURN_V
+    
+      mjMOUSE_TURN_H
+    """
+    __members__: typing.ClassVar[dict[str, mjtMouse]]  # value = {'mjMOUSE_NONE': <mjtMouse.mjMOUSE_NONE: 0>, 'mjMOUSE_ROTATE_V': <mjtMouse.mjMOUSE_ROTATE_V: 1>, 'mjMOUSE_ROTATE_H': <mjtMouse.mjMOUSE_ROTATE_H: 2>, 'mjMOUSE_MOVE_V': <mjtMouse.mjMOUSE_MOVE_V: 3>, 'mjMOUSE_MOVE_H': <mjtMouse.mjMOUSE_MOVE_H: 4>, 'mjMOUSE_ZOOM': <mjtMouse.mjMOUSE_ZOOM: 5>, 'mjMOUSE_MOVE_V_REL': <mjtMouse.mjMOUSE_MOVE_V_REL: 6>, 'mjMOUSE_MOVE_H_REL': <mjtMouse.mjMOUSE_MOVE_H_REL: 7>, 'mjMOUSE_TURN_V': <mjtMouse.mjMOUSE_TURN_V: 8>, 'mjMOUSE_TURN_H': <mjtMouse.mjMOUSE_TURN_H: 9>}
+    mjMOUSE_MOVE_H: typing.ClassVar[mjtMouse]  # value = <mjtMouse.mjMOUSE_MOVE_H: 4>
+    mjMOUSE_MOVE_H_REL: typing.ClassVar[mjtMouse]  # value = <mjtMouse.mjMOUSE_MOVE_H_REL: 7>
+    mjMOUSE_MOVE_V: typing.ClassVar[mjtMouse]  # value = <mjtMouse.mjMOUSE_MOVE_V: 3>
+    mjMOUSE_MOVE_V_REL: typing.ClassVar[mjtMouse]  # value = <mjtMouse.mjMOUSE_MOVE_V_REL: 6>
+    mjMOUSE_NONE: typing.ClassVar[mjtMouse]  # value = <mjtMouse.mjMOUSE_NONE: 0>
+    mjMOUSE_ROTATE_H: typing.ClassVar[mjtMouse]  # value = <mjtMouse.mjMOUSE_ROTATE_H: 2>
+    mjMOUSE_ROTATE_V: typing.ClassVar[mjtMouse]  # value = <mjtMouse.mjMOUSE_ROTATE_V: 1>
+    mjMOUSE_TURN_H: typing.ClassVar[mjtMouse]  # value = <mjtMouse.mjMOUSE_TURN_H: 9>
+    mjMOUSE_TURN_V: typing.ClassVar[mjtMouse]  # value = <mjtMouse.mjMOUSE_TURN_V: 8>
+    mjMOUSE_ZOOM: typing.ClassVar[mjtMouse]  # value = <mjtMouse.mjMOUSE_ZOOM: 5>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtObj:
+    """
+    Members:
+    
+      mjOBJ_UNKNOWN
+    
+      mjOBJ_BODY
+    
+      mjOBJ_XBODY
+    
+      mjOBJ_JOINT
+    
+      mjOBJ_DOF
+    
+      mjOBJ_GEOM
+    
+      mjOBJ_SITE
+    
+      mjOBJ_CAMERA
+    
+      mjOBJ_LIGHT
+    
+      mjOBJ_FLEX
+    
+      mjOBJ_MESH
+    
+      mjOBJ_SKIN
+    
+      mjOBJ_HFIELD
+    
+      mjOBJ_TEXTURE
+    
+      mjOBJ_MATERIAL
+    
+      mjOBJ_PAIR
+    
+      mjOBJ_EXCLUDE
+    
+      mjOBJ_EQUALITY
+    
+      mjOBJ_TENDON
+    
+      mjOBJ_ACTUATOR
+    
+      mjOBJ_SENSOR
+    
+      mjOBJ_NUMERIC
+    
+      mjOBJ_TEXT
+    
+      mjOBJ_TUPLE
+    
+      mjOBJ_KEY
+    
+      mjOBJ_PLUGIN
+    
+      mjNOBJECT
+    
+      mjOBJ_FRAME
+    
+      mjOBJ_DEFAULT
+    
+      mjOBJ_MODEL
+    """
+    __members__: typing.ClassVar[dict[str, mjtObj]]  # value = {'mjOBJ_UNKNOWN': <mjtObj.mjOBJ_UNKNOWN: 0>, 'mjOBJ_BODY': <mjtObj.mjOBJ_BODY: 1>, 'mjOBJ_XBODY': <mjtObj.mjOBJ_XBODY: 2>, 'mjOBJ_JOINT': <mjtObj.mjOBJ_JOINT: 3>, 'mjOBJ_DOF': <mjtObj.mjOBJ_DOF: 4>, 'mjOBJ_GEOM': <mjtObj.mjOBJ_GEOM: 5>, 'mjOBJ_SITE': <mjtObj.mjOBJ_SITE: 6>, 'mjOBJ_CAMERA': <mjtObj.mjOBJ_CAMERA: 7>, 'mjOBJ_LIGHT': <mjtObj.mjOBJ_LIGHT: 8>, 'mjOBJ_FLEX': <mjtObj.mjOBJ_FLEX: 9>, 'mjOBJ_MESH': <mjtObj.mjOBJ_MESH: 10>, 'mjOBJ_SKIN': <mjtObj.mjOBJ_SKIN: 11>, 'mjOBJ_HFIELD': <mjtObj.mjOBJ_HFIELD: 12>, 'mjOBJ_TEXTURE': <mjtObj.mjOBJ_TEXTURE: 13>, 'mjOBJ_MATERIAL': <mjtObj.mjOBJ_MATERIAL: 14>, 'mjOBJ_PAIR': <mjtObj.mjOBJ_PAIR: 15>, 'mjOBJ_EXCLUDE': <mjtObj.mjOBJ_EXCLUDE: 16>, 'mjOBJ_EQUALITY': <mjtObj.mjOBJ_EQUALITY: 17>, 'mjOBJ_TENDON': <mjtObj.mjOBJ_TENDON: 18>, 'mjOBJ_ACTUATOR': <mjtObj.mjOBJ_ACTUATOR: 19>, 'mjOBJ_SENSOR': <mjtObj.mjOBJ_SENSOR: 20>, 'mjOBJ_NUMERIC': <mjtObj.mjOBJ_NUMERIC: 21>, 'mjOBJ_TEXT': <mjtObj.mjOBJ_TEXT: 22>, 'mjOBJ_TUPLE': <mjtObj.mjOBJ_TUPLE: 23>, 'mjOBJ_KEY': <mjtObj.mjOBJ_KEY: 24>, 'mjOBJ_PLUGIN': <mjtObj.mjOBJ_PLUGIN: 25>, 'mjNOBJECT': <mjtObj.mjNOBJECT: 26>, 'mjOBJ_FRAME': <mjtObj.mjOBJ_FRAME: 100>, 'mjOBJ_DEFAULT': <mjtObj.mjOBJ_DEFAULT: 101>, 'mjOBJ_MODEL': <mjtObj.mjOBJ_MODEL: 102>}
+    mjNOBJECT: typing.ClassVar[mjtObj]  # value = <mjtObj.mjNOBJECT: 26>
+    mjOBJ_ACTUATOR: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_ACTUATOR: 19>
+    mjOBJ_BODY: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_BODY: 1>
+    mjOBJ_CAMERA: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_CAMERA: 7>
+    mjOBJ_DEFAULT: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_DEFAULT: 101>
+    mjOBJ_DOF: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_DOF: 4>
+    mjOBJ_EQUALITY: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_EQUALITY: 17>
+    mjOBJ_EXCLUDE: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_EXCLUDE: 16>
+    mjOBJ_FLEX: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_FLEX: 9>
+    mjOBJ_FRAME: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_FRAME: 100>
+    mjOBJ_GEOM: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_GEOM: 5>
+    mjOBJ_HFIELD: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_HFIELD: 12>
+    mjOBJ_JOINT: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_JOINT: 3>
+    mjOBJ_KEY: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_KEY: 24>
+    mjOBJ_LIGHT: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_LIGHT: 8>
+    mjOBJ_MATERIAL: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_MATERIAL: 14>
+    mjOBJ_MESH: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_MESH: 10>
+    mjOBJ_MODEL: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_MODEL: 102>
+    mjOBJ_NUMERIC: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_NUMERIC: 21>
+    mjOBJ_PAIR: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_PAIR: 15>
+    mjOBJ_PLUGIN: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_PLUGIN: 25>
+    mjOBJ_SENSOR: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_SENSOR: 20>
+    mjOBJ_SITE: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_SITE: 6>
+    mjOBJ_SKIN: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_SKIN: 11>
+    mjOBJ_TENDON: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_TENDON: 18>
+    mjOBJ_TEXT: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_TEXT: 22>
+    mjOBJ_TEXTURE: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_TEXTURE: 13>
+    mjOBJ_TUPLE: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_TUPLE: 23>
+    mjOBJ_UNKNOWN: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_UNKNOWN: 0>
+    mjOBJ_XBODY: typing.ClassVar[mjtObj]  # value = <mjtObj.mjOBJ_XBODY: 2>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtOrientation:
+    """
+    Members:
+    
+      mjORIENTATION_QUAT
+    
+      mjORIENTATION_AXISANGLE
+    
+      mjORIENTATION_XYAXES
+    
+      mjORIENTATION_ZAXIS
+    
+      mjORIENTATION_EULER
+    """
+    __members__: typing.ClassVar[dict[str, mjtOrientation]]  # value = {'mjORIENTATION_QUAT': <mjtOrientation.mjORIENTATION_QUAT: 0>, 'mjORIENTATION_AXISANGLE': <mjtOrientation.mjORIENTATION_AXISANGLE: 1>, 'mjORIENTATION_XYAXES': <mjtOrientation.mjORIENTATION_XYAXES: 2>, 'mjORIENTATION_ZAXIS': <mjtOrientation.mjORIENTATION_ZAXIS: 3>, 'mjORIENTATION_EULER': <mjtOrientation.mjORIENTATION_EULER: 4>}
+    mjORIENTATION_AXISANGLE: typing.ClassVar[mjtOrientation]  # value = <mjtOrientation.mjORIENTATION_AXISANGLE: 1>
+    mjORIENTATION_EULER: typing.ClassVar[mjtOrientation]  # value = <mjtOrientation.mjORIENTATION_EULER: 4>
+    mjORIENTATION_QUAT: typing.ClassVar[mjtOrientation]  # value = <mjtOrientation.mjORIENTATION_QUAT: 0>
+    mjORIENTATION_XYAXES: typing.ClassVar[mjtOrientation]  # value = <mjtOrientation.mjORIENTATION_XYAXES: 2>
+    mjORIENTATION_ZAXIS: typing.ClassVar[mjtOrientation]  # value = <mjtOrientation.mjORIENTATION_ZAXIS: 3>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtPertBit:
+    """
+    Members:
+    
+      mjPERT_TRANSLATE
+    
+      mjPERT_ROTATE
+    """
+    __members__: typing.ClassVar[dict[str, mjtPertBit]]  # value = {'mjPERT_TRANSLATE': <mjtPertBit.mjPERT_TRANSLATE: 1>, 'mjPERT_ROTATE': <mjtPertBit.mjPERT_ROTATE: 2>}
+    mjPERT_ROTATE: typing.ClassVar[mjtPertBit]  # value = <mjtPertBit.mjPERT_ROTATE: 2>
+    mjPERT_TRANSLATE: typing.ClassVar[mjtPertBit]  # value = <mjtPertBit.mjPERT_TRANSLATE: 1>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtPluginCapabilityBit:
+    """
+    Members:
+    
+      mjPLUGIN_ACTUATOR
+    
+      mjPLUGIN_SENSOR
+    
+      mjPLUGIN_PASSIVE
+    
+      mjPLUGIN_SDF
+    """
+    __members__: typing.ClassVar[dict[str, mjtPluginCapabilityBit]]  # value = {'mjPLUGIN_ACTUATOR': <mjtPluginCapabilityBit.mjPLUGIN_ACTUATOR: 1>, 'mjPLUGIN_SENSOR': <mjtPluginCapabilityBit.mjPLUGIN_SENSOR: 2>, 'mjPLUGIN_PASSIVE': <mjtPluginCapabilityBit.mjPLUGIN_PASSIVE: 4>, 'mjPLUGIN_SDF': <mjtPluginCapabilityBit.mjPLUGIN_SDF: 8>}
+    mjPLUGIN_ACTUATOR: typing.ClassVar[mjtPluginCapabilityBit]  # value = <mjtPluginCapabilityBit.mjPLUGIN_ACTUATOR: 1>
+    mjPLUGIN_PASSIVE: typing.ClassVar[mjtPluginCapabilityBit]  # value = <mjtPluginCapabilityBit.mjPLUGIN_PASSIVE: 4>
+    mjPLUGIN_SDF: typing.ClassVar[mjtPluginCapabilityBit]  # value = <mjtPluginCapabilityBit.mjPLUGIN_SDF: 8>
+    mjPLUGIN_SENSOR: typing.ClassVar[mjtPluginCapabilityBit]  # value = <mjtPluginCapabilityBit.mjPLUGIN_SENSOR: 2>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtProjection:
+    """
+    Members:
+    
+      mjPROJ_PERSPECTIVE
+    
+      mjPROJ_ORTHOGRAPHIC
+    """
+    __members__: typing.ClassVar[dict[str, mjtProjection]]  # value = {'mjPROJ_PERSPECTIVE': <mjtProjection.mjPROJ_PERSPECTIVE: 0>, 'mjPROJ_ORTHOGRAPHIC': <mjtProjection.mjPROJ_ORTHOGRAPHIC: 1>}
+    mjPROJ_ORTHOGRAPHIC: typing.ClassVar[mjtProjection]  # value = <mjtProjection.mjPROJ_ORTHOGRAPHIC: 1>
+    mjPROJ_PERSPECTIVE: typing.ClassVar[mjtProjection]  # value = <mjtProjection.mjPROJ_PERSPECTIVE: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtRayDataField:
+    """
+    Members:
+    
+      mjRAYDATA_DIST
+    
+      mjRAYDATA_DIR
+    
+      mjRAYDATA_ORIGIN
+    
+      mjRAYDATA_POINT
+    
+      mjRAYDATA_NORMAL
+    
+      mjRAYDATA_DEPTH
+    
+      mjNRAYDATA
+    """
+    __members__: typing.ClassVar[dict[str, mjtRayDataField]]  # value = {'mjRAYDATA_DIST': <mjtRayDataField.mjRAYDATA_DIST: 0>, 'mjRAYDATA_DIR': <mjtRayDataField.mjRAYDATA_DIR: 1>, 'mjRAYDATA_ORIGIN': <mjtRayDataField.mjRAYDATA_ORIGIN: 2>, 'mjRAYDATA_POINT': <mjtRayDataField.mjRAYDATA_POINT: 3>, 'mjRAYDATA_NORMAL': <mjtRayDataField.mjRAYDATA_NORMAL: 4>, 'mjRAYDATA_DEPTH': <mjtRayDataField.mjRAYDATA_DEPTH: 5>, 'mjNRAYDATA': <mjtRayDataField.mjNRAYDATA: 6>}
+    mjNRAYDATA: typing.ClassVar[mjtRayDataField]  # value = <mjtRayDataField.mjNRAYDATA: 6>
+    mjRAYDATA_DEPTH: typing.ClassVar[mjtRayDataField]  # value = <mjtRayDataField.mjRAYDATA_DEPTH: 5>
+    mjRAYDATA_DIR: typing.ClassVar[mjtRayDataField]  # value = <mjtRayDataField.mjRAYDATA_DIR: 1>
+    mjRAYDATA_DIST: typing.ClassVar[mjtRayDataField]  # value = <mjtRayDataField.mjRAYDATA_DIST: 0>
+    mjRAYDATA_NORMAL: typing.ClassVar[mjtRayDataField]  # value = <mjtRayDataField.mjRAYDATA_NORMAL: 4>
+    mjRAYDATA_ORIGIN: typing.ClassVar[mjtRayDataField]  # value = <mjtRayDataField.mjRAYDATA_ORIGIN: 2>
+    mjRAYDATA_POINT: typing.ClassVar[mjtRayDataField]  # value = <mjtRayDataField.mjRAYDATA_POINT: 3>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtRndFlag:
+    """
+    Members:
+    
+      mjRND_SHADOW
+    
+      mjRND_WIREFRAME
+    
+      mjRND_REFLECTION
+    
+      mjRND_ADDITIVE
+    
+      mjRND_SKYBOX
+    
+      mjRND_FOG
+    
+      mjRND_HAZE
+    
+      mjRND_DEPTH
+    
+      mjRND_SEGMENT
+    
+      mjRND_IDCOLOR
+    
+      mjRND_CULL_FACE
+    
+      mjNRNDFLAG
+    """
+    __members__: typing.ClassVar[dict[str, mjtRndFlag]]  # value = {'mjRND_SHADOW': <mjtRndFlag.mjRND_SHADOW: 0>, 'mjRND_WIREFRAME': <mjtRndFlag.mjRND_WIREFRAME: 1>, 'mjRND_REFLECTION': <mjtRndFlag.mjRND_REFLECTION: 2>, 'mjRND_ADDITIVE': <mjtRndFlag.mjRND_ADDITIVE: 3>, 'mjRND_SKYBOX': <mjtRndFlag.mjRND_SKYBOX: 4>, 'mjRND_FOG': <mjtRndFlag.mjRND_FOG: 5>, 'mjRND_HAZE': <mjtRndFlag.mjRND_HAZE: 6>, 'mjRND_DEPTH': <mjtRndFlag.mjRND_DEPTH: 7>, 'mjRND_SEGMENT': <mjtRndFlag.mjRND_SEGMENT: 8>, 'mjRND_IDCOLOR': <mjtRndFlag.mjRND_IDCOLOR: 9>, 'mjRND_CULL_FACE': <mjtRndFlag.mjRND_CULL_FACE: 10>, 'mjNRNDFLAG': <mjtRndFlag.mjNRNDFLAG: 11>}
+    mjNRNDFLAG: typing.ClassVar[mjtRndFlag]  # value = <mjtRndFlag.mjNRNDFLAG: 11>
+    mjRND_ADDITIVE: typing.ClassVar[mjtRndFlag]  # value = <mjtRndFlag.mjRND_ADDITIVE: 3>
+    mjRND_CULL_FACE: typing.ClassVar[mjtRndFlag]  # value = <mjtRndFlag.mjRND_CULL_FACE: 10>
+    mjRND_DEPTH: typing.ClassVar[mjtRndFlag]  # value = <mjtRndFlag.mjRND_DEPTH: 7>
+    mjRND_FOG: typing.ClassVar[mjtRndFlag]  # value = <mjtRndFlag.mjRND_FOG: 5>
+    mjRND_HAZE: typing.ClassVar[mjtRndFlag]  # value = <mjtRndFlag.mjRND_HAZE: 6>
+    mjRND_IDCOLOR: typing.ClassVar[mjtRndFlag]  # value = <mjtRndFlag.mjRND_IDCOLOR: 9>
+    mjRND_REFLECTION: typing.ClassVar[mjtRndFlag]  # value = <mjtRndFlag.mjRND_REFLECTION: 2>
+    mjRND_SEGMENT: typing.ClassVar[mjtRndFlag]  # value = <mjtRndFlag.mjRND_SEGMENT: 8>
+    mjRND_SHADOW: typing.ClassVar[mjtRndFlag]  # value = <mjtRndFlag.mjRND_SHADOW: 0>
+    mjRND_SKYBOX: typing.ClassVar[mjtRndFlag]  # value = <mjtRndFlag.mjRND_SKYBOX: 4>
+    mjRND_WIREFRAME: typing.ClassVar[mjtRndFlag]  # value = <mjtRndFlag.mjRND_WIREFRAME: 1>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtSDFType:
+    """
+    Members:
+    
+      mjSDFTYPE_SINGLE
+    
+      mjSDFTYPE_INTERSECTION
+    
+      mjSDFTYPE_MIDSURFACE
+    
+      mjSDFTYPE_COLLISION
+    """
+    __members__: typing.ClassVar[dict[str, mjtSDFType]]  # value = {'mjSDFTYPE_SINGLE': <mjtSDFType.mjSDFTYPE_SINGLE: 0>, 'mjSDFTYPE_INTERSECTION': <mjtSDFType.mjSDFTYPE_INTERSECTION: 1>, 'mjSDFTYPE_MIDSURFACE': <mjtSDFType.mjSDFTYPE_MIDSURFACE: 2>, 'mjSDFTYPE_COLLISION': <mjtSDFType.mjSDFTYPE_COLLISION: 3>}
+    mjSDFTYPE_COLLISION: typing.ClassVar[mjtSDFType]  # value = <mjtSDFType.mjSDFTYPE_COLLISION: 3>
+    mjSDFTYPE_INTERSECTION: typing.ClassVar[mjtSDFType]  # value = <mjtSDFType.mjSDFTYPE_INTERSECTION: 1>
+    mjSDFTYPE_MIDSURFACE: typing.ClassVar[mjtSDFType]  # value = <mjtSDFType.mjSDFTYPE_MIDSURFACE: 2>
+    mjSDFTYPE_SINGLE: typing.ClassVar[mjtSDFType]  # value = <mjtSDFType.mjSDFTYPE_SINGLE: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtSameFrame:
+    """
+    Members:
+    
+      mjSAMEFRAME_NONE
+    
+      mjSAMEFRAME_BODY
+    
+      mjSAMEFRAME_INERTIA
+    
+      mjSAMEFRAME_BODYROT
+    
+      mjSAMEFRAME_INERTIAROT
+    """
+    __members__: typing.ClassVar[dict[str, mjtSameFrame]]  # value = {'mjSAMEFRAME_NONE': <mjtSameFrame.mjSAMEFRAME_NONE: 0>, 'mjSAMEFRAME_BODY': <mjtSameFrame.mjSAMEFRAME_BODY: 1>, 'mjSAMEFRAME_INERTIA': <mjtSameFrame.mjSAMEFRAME_INERTIA: 2>, 'mjSAMEFRAME_BODYROT': <mjtSameFrame.mjSAMEFRAME_BODYROT: 3>, 'mjSAMEFRAME_INERTIAROT': <mjtSameFrame.mjSAMEFRAME_INERTIAROT: 4>}
+    mjSAMEFRAME_BODY: typing.ClassVar[mjtSameFrame]  # value = <mjtSameFrame.mjSAMEFRAME_BODY: 1>
+    mjSAMEFRAME_BODYROT: typing.ClassVar[mjtSameFrame]  # value = <mjtSameFrame.mjSAMEFRAME_BODYROT: 3>
+    mjSAMEFRAME_INERTIA: typing.ClassVar[mjtSameFrame]  # value = <mjtSameFrame.mjSAMEFRAME_INERTIA: 2>
+    mjSAMEFRAME_INERTIAROT: typing.ClassVar[mjtSameFrame]  # value = <mjtSameFrame.mjSAMEFRAME_INERTIAROT: 4>
+    mjSAMEFRAME_NONE: typing.ClassVar[mjtSameFrame]  # value = <mjtSameFrame.mjSAMEFRAME_NONE: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtSection:
+    """
+    Members:
+    
+      mjSECT_CLOSED
+    
+      mjSECT_OPEN
+    
+      mjSECT_FIXED
+    """
+    __members__: typing.ClassVar[dict[str, mjtSection]]  # value = {'mjSECT_CLOSED': <mjtSection.mjSECT_CLOSED: 0>, 'mjSECT_OPEN': <mjtSection.mjSECT_OPEN: 1>, 'mjSECT_FIXED': <mjtSection.mjSECT_FIXED: 2>}
+    mjSECT_CLOSED: typing.ClassVar[mjtSection]  # value = <mjtSection.mjSECT_CLOSED: 0>
+    mjSECT_FIXED: typing.ClassVar[mjtSection]  # value = <mjtSection.mjSECT_FIXED: 2>
+    mjSECT_OPEN: typing.ClassVar[mjtSection]  # value = <mjtSection.mjSECT_OPEN: 1>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtSensor:
+    """
+    Members:
+    
+      mjSENS_TOUCH
+    
+      mjSENS_ACCELEROMETER
+    
+      mjSENS_VELOCIMETER
+    
+      mjSENS_GYRO
+    
+      mjSENS_FORCE
+    
+      mjSENS_TORQUE
+    
+      mjSENS_MAGNETOMETER
+    
+      mjSENS_RANGEFINDER
+    
+      mjSENS_CAMPROJECTION
+    
+      mjSENS_JOINTPOS
+    
+      mjSENS_JOINTVEL
+    
+      mjSENS_TENDONPOS
+    
+      mjSENS_TENDONVEL
+    
+      mjSENS_ACTUATORPOS
+    
+      mjSENS_ACTUATORVEL
+    
+      mjSENS_ACTUATORFRC
+    
+      mjSENS_JOINTACTFRC
+    
+      mjSENS_TENDONACTFRC
+    
+      mjSENS_BALLQUAT
+    
+      mjSENS_BALLANGVEL
+    
+      mjSENS_JOINTLIMITPOS
+    
+      mjSENS_JOINTLIMITVEL
+    
+      mjSENS_JOINTLIMITFRC
+    
+      mjSENS_TENDONLIMITPOS
+    
+      mjSENS_TENDONLIMITVEL
+    
+      mjSENS_TENDONLIMITFRC
+    
+      mjSENS_FRAMEPOS
+    
+      mjSENS_FRAMEQUAT
+    
+      mjSENS_FRAMEXAXIS
+    
+      mjSENS_FRAMEYAXIS
+    
+      mjSENS_FRAMEZAXIS
+    
+      mjSENS_FRAMELINVEL
+    
+      mjSENS_FRAMEANGVEL
+    
+      mjSENS_FRAMELINACC
+    
+      mjSENS_FRAMEANGACC
+    
+      mjSENS_SUBTREECOM
+    
+      mjSENS_SUBTREELINVEL
+    
+      mjSENS_SUBTREEANGMOM
+    
+      mjSENS_INSIDESITE
+    
+      mjSENS_GEOMDIST
+    
+      mjSENS_GEOMNORMAL
+    
+      mjSENS_GEOMFROMTO
+    
+      mjSENS_CONTACT
+    
+      mjSENS_E_POTENTIAL
+    
+      mjSENS_E_KINETIC
+    
+      mjSENS_CLOCK
+    
+      mjSENS_TACTILE
+    
+      mjSENS_PLUGIN
+    
+      mjSENS_USER
+    """
+    __members__: typing.ClassVar[dict[str, mjtSensor]]  # value = {'mjSENS_TOUCH': <mjtSensor.mjSENS_TOUCH: 0>, 'mjSENS_ACCELEROMETER': <mjtSensor.mjSENS_ACCELEROMETER: 1>, 'mjSENS_VELOCIMETER': <mjtSensor.mjSENS_VELOCIMETER: 2>, 'mjSENS_GYRO': <mjtSensor.mjSENS_GYRO: 3>, 'mjSENS_FORCE': <mjtSensor.mjSENS_FORCE: 4>, 'mjSENS_TORQUE': <mjtSensor.mjSENS_TORQUE: 5>, 'mjSENS_MAGNETOMETER': <mjtSensor.mjSENS_MAGNETOMETER: 6>, 'mjSENS_RANGEFINDER': <mjtSensor.mjSENS_RANGEFINDER: 7>, 'mjSENS_CAMPROJECTION': <mjtSensor.mjSENS_CAMPROJECTION: 8>, 'mjSENS_JOINTPOS': <mjtSensor.mjSENS_JOINTPOS: 9>, 'mjSENS_JOINTVEL': <mjtSensor.mjSENS_JOINTVEL: 10>, 'mjSENS_TENDONPOS': <mjtSensor.mjSENS_TENDONPOS: 11>, 'mjSENS_TENDONVEL': <mjtSensor.mjSENS_TENDONVEL: 12>, 'mjSENS_ACTUATORPOS': <mjtSensor.mjSENS_ACTUATORPOS: 13>, 'mjSENS_ACTUATORVEL': <mjtSensor.mjSENS_ACTUATORVEL: 14>, 'mjSENS_ACTUATORFRC': <mjtSensor.mjSENS_ACTUATORFRC: 15>, 'mjSENS_JOINTACTFRC': <mjtSensor.mjSENS_JOINTACTFRC: 16>, 'mjSENS_TENDONACTFRC': <mjtSensor.mjSENS_TENDONACTFRC: 17>, 'mjSENS_BALLQUAT': <mjtSensor.mjSENS_BALLQUAT: 18>, 'mjSENS_BALLANGVEL': <mjtSensor.mjSENS_BALLANGVEL: 19>, 'mjSENS_JOINTLIMITPOS': <mjtSensor.mjSENS_JOINTLIMITPOS: 20>, 'mjSENS_JOINTLIMITVEL': <mjtSensor.mjSENS_JOINTLIMITVEL: 21>, 'mjSENS_JOINTLIMITFRC': <mjtSensor.mjSENS_JOINTLIMITFRC: 22>, 'mjSENS_TENDONLIMITPOS': <mjtSensor.mjSENS_TENDONLIMITPOS: 23>, 'mjSENS_TENDONLIMITVEL': <mjtSensor.mjSENS_TENDONLIMITVEL: 24>, 'mjSENS_TENDONLIMITFRC': <mjtSensor.mjSENS_TENDONLIMITFRC: 25>, 'mjSENS_FRAMEPOS': <mjtSensor.mjSENS_FRAMEPOS: 26>, 'mjSENS_FRAMEQUAT': <mjtSensor.mjSENS_FRAMEQUAT: 27>, 'mjSENS_FRAMEXAXIS': <mjtSensor.mjSENS_FRAMEXAXIS: 28>, 'mjSENS_FRAMEYAXIS': <mjtSensor.mjSENS_FRAMEYAXIS: 29>, 'mjSENS_FRAMEZAXIS': <mjtSensor.mjSENS_FRAMEZAXIS: 30>, 'mjSENS_FRAMELINVEL': <mjtSensor.mjSENS_FRAMELINVEL: 31>, 'mjSENS_FRAMEANGVEL': <mjtSensor.mjSENS_FRAMEANGVEL: 32>, 'mjSENS_FRAMELINACC': <mjtSensor.mjSENS_FRAMELINACC: 33>, 'mjSENS_FRAMEANGACC': <mjtSensor.mjSENS_FRAMEANGACC: 34>, 'mjSENS_SUBTREECOM': <mjtSensor.mjSENS_SUBTREECOM: 35>, 'mjSENS_SUBTREELINVEL': <mjtSensor.mjSENS_SUBTREELINVEL: 36>, 'mjSENS_SUBTREEANGMOM': <mjtSensor.mjSENS_SUBTREEANGMOM: 37>, 'mjSENS_INSIDESITE': <mjtSensor.mjSENS_INSIDESITE: 38>, 'mjSENS_GEOMDIST': <mjtSensor.mjSENS_GEOMDIST: 39>, 'mjSENS_GEOMNORMAL': <mjtSensor.mjSENS_GEOMNORMAL: 40>, 'mjSENS_GEOMFROMTO': <mjtSensor.mjSENS_GEOMFROMTO: 41>, 'mjSENS_CONTACT': <mjtSensor.mjSENS_CONTACT: 42>, 'mjSENS_E_POTENTIAL': <mjtSensor.mjSENS_E_POTENTIAL: 43>, 'mjSENS_E_KINETIC': <mjtSensor.mjSENS_E_KINETIC: 44>, 'mjSENS_CLOCK': <mjtSensor.mjSENS_CLOCK: 45>, 'mjSENS_TACTILE': <mjtSensor.mjSENS_TACTILE: 46>, 'mjSENS_PLUGIN': <mjtSensor.mjSENS_PLUGIN: 47>, 'mjSENS_USER': <mjtSensor.mjSENS_USER: 48>}
+    mjSENS_ACCELEROMETER: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_ACCELEROMETER: 1>
+    mjSENS_ACTUATORFRC: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_ACTUATORFRC: 15>
+    mjSENS_ACTUATORPOS: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_ACTUATORPOS: 13>
+    mjSENS_ACTUATORVEL: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_ACTUATORVEL: 14>
+    mjSENS_BALLANGVEL: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_BALLANGVEL: 19>
+    mjSENS_BALLQUAT: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_BALLQUAT: 18>
+    mjSENS_CAMPROJECTION: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_CAMPROJECTION: 8>
+    mjSENS_CLOCK: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_CLOCK: 45>
+    mjSENS_CONTACT: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_CONTACT: 42>
+    mjSENS_E_KINETIC: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_E_KINETIC: 44>
+    mjSENS_E_POTENTIAL: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_E_POTENTIAL: 43>
+    mjSENS_FORCE: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_FORCE: 4>
+    mjSENS_FRAMEANGACC: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_FRAMEANGACC: 34>
+    mjSENS_FRAMEANGVEL: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_FRAMEANGVEL: 32>
+    mjSENS_FRAMELINACC: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_FRAMELINACC: 33>
+    mjSENS_FRAMELINVEL: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_FRAMELINVEL: 31>
+    mjSENS_FRAMEPOS: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_FRAMEPOS: 26>
+    mjSENS_FRAMEQUAT: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_FRAMEQUAT: 27>
+    mjSENS_FRAMEXAXIS: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_FRAMEXAXIS: 28>
+    mjSENS_FRAMEYAXIS: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_FRAMEYAXIS: 29>
+    mjSENS_FRAMEZAXIS: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_FRAMEZAXIS: 30>
+    mjSENS_GEOMDIST: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_GEOMDIST: 39>
+    mjSENS_GEOMFROMTO: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_GEOMFROMTO: 41>
+    mjSENS_GEOMNORMAL: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_GEOMNORMAL: 40>
+    mjSENS_GYRO: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_GYRO: 3>
+    mjSENS_INSIDESITE: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_INSIDESITE: 38>
+    mjSENS_JOINTACTFRC: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_JOINTACTFRC: 16>
+    mjSENS_JOINTLIMITFRC: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_JOINTLIMITFRC: 22>
+    mjSENS_JOINTLIMITPOS: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_JOINTLIMITPOS: 20>
+    mjSENS_JOINTLIMITVEL: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_JOINTLIMITVEL: 21>
+    mjSENS_JOINTPOS: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_JOINTPOS: 9>
+    mjSENS_JOINTVEL: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_JOINTVEL: 10>
+    mjSENS_MAGNETOMETER: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_MAGNETOMETER: 6>
+    mjSENS_PLUGIN: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_PLUGIN: 47>
+    mjSENS_RANGEFINDER: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_RANGEFINDER: 7>
+    mjSENS_SUBTREEANGMOM: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_SUBTREEANGMOM: 37>
+    mjSENS_SUBTREECOM: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_SUBTREECOM: 35>
+    mjSENS_SUBTREELINVEL: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_SUBTREELINVEL: 36>
+    mjSENS_TACTILE: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_TACTILE: 46>
+    mjSENS_TENDONACTFRC: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_TENDONACTFRC: 17>
+    mjSENS_TENDONLIMITFRC: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_TENDONLIMITFRC: 25>
+    mjSENS_TENDONLIMITPOS: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_TENDONLIMITPOS: 23>
+    mjSENS_TENDONLIMITVEL: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_TENDONLIMITVEL: 24>
+    mjSENS_TENDONPOS: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_TENDONPOS: 11>
+    mjSENS_TENDONVEL: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_TENDONVEL: 12>
+    mjSENS_TORQUE: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_TORQUE: 5>
+    mjSENS_TOUCH: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_TOUCH: 0>
+    mjSENS_USER: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_USER: 48>
+    mjSENS_VELOCIMETER: typing.ClassVar[mjtSensor]  # value = <mjtSensor.mjSENS_VELOCIMETER: 2>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtSleepPolicy:
+    """
+    Members:
+    
+      mjSLEEP_AUTO
+    
+      mjSLEEP_AUTO_NEVER
+    
+      mjSLEEP_AUTO_ALLOWED
+    
+      mjSLEEP_NEVER
+    
+      mjSLEEP_ALLOWED
+    
+      mjSLEEP_INIT
+    """
+    __members__: typing.ClassVar[dict[str, mjtSleepPolicy]]  # value = {'mjSLEEP_AUTO': <mjtSleepPolicy.mjSLEEP_AUTO: 0>, 'mjSLEEP_AUTO_NEVER': <mjtSleepPolicy.mjSLEEP_AUTO_NEVER: 1>, 'mjSLEEP_AUTO_ALLOWED': <mjtSleepPolicy.mjSLEEP_AUTO_ALLOWED: 2>, 'mjSLEEP_NEVER': <mjtSleepPolicy.mjSLEEP_NEVER: 3>, 'mjSLEEP_ALLOWED': <mjtSleepPolicy.mjSLEEP_ALLOWED: 4>, 'mjSLEEP_INIT': <mjtSleepPolicy.mjSLEEP_INIT: 5>}
+    mjSLEEP_ALLOWED: typing.ClassVar[mjtSleepPolicy]  # value = <mjtSleepPolicy.mjSLEEP_ALLOWED: 4>
+    mjSLEEP_AUTO: typing.ClassVar[mjtSleepPolicy]  # value = <mjtSleepPolicy.mjSLEEP_AUTO: 0>
+    mjSLEEP_AUTO_ALLOWED: typing.ClassVar[mjtSleepPolicy]  # value = <mjtSleepPolicy.mjSLEEP_AUTO_ALLOWED: 2>
+    mjSLEEP_AUTO_NEVER: typing.ClassVar[mjtSleepPolicy]  # value = <mjtSleepPolicy.mjSLEEP_AUTO_NEVER: 1>
+    mjSLEEP_INIT: typing.ClassVar[mjtSleepPolicy]  # value = <mjtSleepPolicy.mjSLEEP_INIT: 5>
+    mjSLEEP_NEVER: typing.ClassVar[mjtSleepPolicy]  # value = <mjtSleepPolicy.mjSLEEP_NEVER: 3>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtSleepState:
+    """
+    Members:
+    
+      mjS_STATIC
+    
+      mjS_ASLEEP
+    
+      mjS_AWAKE
+    """
+    __members__: typing.ClassVar[dict[str, mjtSleepState]]  # value = {'mjS_STATIC': <mjtSleepState.mjS_STATIC: -1>, 'mjS_ASLEEP': <mjtSleepState.mjS_ASLEEP: 0>, 'mjS_AWAKE': <mjtSleepState.mjS_AWAKE: 1>}
+    mjS_ASLEEP: typing.ClassVar[mjtSleepState]  # value = <mjtSleepState.mjS_ASLEEP: 0>
+    mjS_AWAKE: typing.ClassVar[mjtSleepState]  # value = <mjtSleepState.mjS_AWAKE: 1>
+    mjS_STATIC: typing.ClassVar[mjtSleepState]  # value = <mjtSleepState.mjS_STATIC: -1>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtSolver:
+    """
+    Members:
+    
+      mjSOL_PGS
+    
+      mjSOL_CG
+    
+      mjSOL_NEWTON
+    """
+    __members__: typing.ClassVar[dict[str, mjtSolver]]  # value = {'mjSOL_PGS': <mjtSolver.mjSOL_PGS: 0>, 'mjSOL_CG': <mjtSolver.mjSOL_CG: 1>, 'mjSOL_NEWTON': <mjtSolver.mjSOL_NEWTON: 2>}
+    mjSOL_CG: typing.ClassVar[mjtSolver]  # value = <mjtSolver.mjSOL_CG: 1>
+    mjSOL_NEWTON: typing.ClassVar[mjtSolver]  # value = <mjtSolver.mjSOL_NEWTON: 2>
+    mjSOL_PGS: typing.ClassVar[mjtSolver]  # value = <mjtSolver.mjSOL_PGS: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtStage:
+    """
+    Members:
+    
+      mjSTAGE_NONE
+    
+      mjSTAGE_POS
+    
+      mjSTAGE_VEL
+    
+      mjSTAGE_ACC
+    """
+    __members__: typing.ClassVar[dict[str, mjtStage]]  # value = {'mjSTAGE_NONE': <mjtStage.mjSTAGE_NONE: 0>, 'mjSTAGE_POS': <mjtStage.mjSTAGE_POS: 1>, 'mjSTAGE_VEL': <mjtStage.mjSTAGE_VEL: 2>, 'mjSTAGE_ACC': <mjtStage.mjSTAGE_ACC: 3>}
+    mjSTAGE_ACC: typing.ClassVar[mjtStage]  # value = <mjtStage.mjSTAGE_ACC: 3>
+    mjSTAGE_NONE: typing.ClassVar[mjtStage]  # value = <mjtStage.mjSTAGE_NONE: 0>
+    mjSTAGE_POS: typing.ClassVar[mjtStage]  # value = <mjtStage.mjSTAGE_POS: 1>
+    mjSTAGE_VEL: typing.ClassVar[mjtStage]  # value = <mjtStage.mjSTAGE_VEL: 2>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtState:
+    """
+    Members:
+    
+      mjSTATE_TIME
+    
+      mjSTATE_QPOS
+    
+      mjSTATE_QVEL
+    
+      mjSTATE_ACT
+    
+      mjSTATE_HISTORY
+    
+      mjSTATE_WARMSTART
+    
+      mjSTATE_CTRL
+    
+      mjSTATE_QFRC_APPLIED
+    
+      mjSTATE_XFRC_APPLIED
+    
+      mjSTATE_EQ_ACTIVE
+    
+      mjSTATE_MOCAP_POS
+    
+      mjSTATE_MOCAP_QUAT
+    
+      mjSTATE_USERDATA
+    
+      mjSTATE_PLUGIN
+    
+      mjNSTATE
+    
+      mjSTATE_PHYSICS
+    
+      mjSTATE_FULLPHYSICS
+    
+      mjSTATE_USER
+    
+      mjSTATE_INTEGRATION
+    """
+    __members__: typing.ClassVar[dict[str, mjtState]]  # value = {'mjSTATE_TIME': <mjtState.mjSTATE_TIME: 1>, 'mjSTATE_QPOS': <mjtState.mjSTATE_QPOS: 2>, 'mjSTATE_QVEL': <mjtState.mjSTATE_QVEL: 4>, 'mjSTATE_ACT': <mjtState.mjSTATE_ACT: 8>, 'mjSTATE_HISTORY': <mjtState.mjSTATE_HISTORY: 16>, 'mjSTATE_WARMSTART': <mjtState.mjSTATE_WARMSTART: 32>, 'mjSTATE_CTRL': <mjtState.mjSTATE_CTRL: 64>, 'mjSTATE_QFRC_APPLIED': <mjtState.mjSTATE_QFRC_APPLIED: 128>, 'mjSTATE_XFRC_APPLIED': <mjtState.mjSTATE_XFRC_APPLIED: 256>, 'mjSTATE_EQ_ACTIVE': <mjtState.mjSTATE_EQ_ACTIVE: 512>, 'mjSTATE_MOCAP_POS': <mjtState.mjSTATE_MOCAP_POS: 1024>, 'mjSTATE_MOCAP_QUAT': <mjtState.mjSTATE_MOCAP_QUAT: 2048>, 'mjSTATE_USERDATA': <mjtState.mjSTATE_USERDATA: 4096>, 'mjSTATE_PLUGIN': <mjtState.mjSTATE_PLUGIN: 8192>, 'mjNSTATE': <mjtState.mjNSTATE: 14>, 'mjSTATE_PHYSICS': <mjtState.mjSTATE_PHYSICS: 30>, 'mjSTATE_FULLPHYSICS': <mjtState.mjSTATE_FULLPHYSICS: 8223>, 'mjSTATE_USER': <mjtState.mjSTATE_USER: 8128>, 'mjSTATE_INTEGRATION': <mjtState.mjSTATE_INTEGRATION: 16383>}
+    mjNSTATE: typing.ClassVar[mjtState]  # value = <mjtState.mjNSTATE: 14>
+    mjSTATE_ACT: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_ACT: 8>
+    mjSTATE_CTRL: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_CTRL: 64>
+    mjSTATE_EQ_ACTIVE: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_EQ_ACTIVE: 512>
+    mjSTATE_FULLPHYSICS: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_FULLPHYSICS: 8223>
+    mjSTATE_HISTORY: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_HISTORY: 16>
+    mjSTATE_INTEGRATION: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_INTEGRATION: 16383>
+    mjSTATE_MOCAP_POS: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_MOCAP_POS: 1024>
+    mjSTATE_MOCAP_QUAT: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_MOCAP_QUAT: 2048>
+    mjSTATE_PHYSICS: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_PHYSICS: 30>
+    mjSTATE_PLUGIN: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_PLUGIN: 8192>
+    mjSTATE_QFRC_APPLIED: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_QFRC_APPLIED: 128>
+    mjSTATE_QPOS: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_QPOS: 2>
+    mjSTATE_QVEL: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_QVEL: 4>
+    mjSTATE_TIME: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_TIME: 1>
+    mjSTATE_USER: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_USER: 8128>
+    mjSTATE_USERDATA: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_USERDATA: 4096>
+    mjSTATE_WARMSTART: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_WARMSTART: 32>
+    mjSTATE_XFRC_APPLIED: typing.ClassVar[mjtState]  # value = <mjtState.mjSTATE_XFRC_APPLIED: 256>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtStereo:
+    """
+    Members:
+    
+      mjSTEREO_NONE
+    
+      mjSTEREO_QUADBUFFERED
+    
+      mjSTEREO_SIDEBYSIDE
+    """
+    __members__: typing.ClassVar[dict[str, mjtStereo]]  # value = {'mjSTEREO_NONE': <mjtStereo.mjSTEREO_NONE: 0>, 'mjSTEREO_QUADBUFFERED': <mjtStereo.mjSTEREO_QUADBUFFERED: 1>, 'mjSTEREO_SIDEBYSIDE': <mjtStereo.mjSTEREO_SIDEBYSIDE: 2>}
+    mjSTEREO_NONE: typing.ClassVar[mjtStereo]  # value = <mjtStereo.mjSTEREO_NONE: 0>
+    mjSTEREO_QUADBUFFERED: typing.ClassVar[mjtStereo]  # value = <mjtStereo.mjSTEREO_QUADBUFFERED: 1>
+    mjSTEREO_SIDEBYSIDE: typing.ClassVar[mjtStereo]  # value = <mjtStereo.mjSTEREO_SIDEBYSIDE: 2>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtTexture:
+    """
+    Members:
+    
+      mjTEXTURE_2D
+    
+      mjTEXTURE_CUBE
+    
+      mjTEXTURE_SKYBOX
+    """
+    __members__: typing.ClassVar[dict[str, mjtTexture]]  # value = {'mjTEXTURE_2D': <mjtTexture.mjTEXTURE_2D: 0>, 'mjTEXTURE_CUBE': <mjtTexture.mjTEXTURE_CUBE: 1>, 'mjTEXTURE_SKYBOX': <mjtTexture.mjTEXTURE_SKYBOX: 2>}
+    mjTEXTURE_2D: typing.ClassVar[mjtTexture]  # value = <mjtTexture.mjTEXTURE_2D: 0>
+    mjTEXTURE_CUBE: typing.ClassVar[mjtTexture]  # value = <mjtTexture.mjTEXTURE_CUBE: 1>
+    mjTEXTURE_SKYBOX: typing.ClassVar[mjtTexture]  # value = <mjtTexture.mjTEXTURE_SKYBOX: 2>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtTextureRole:
+    """
+    Members:
+    
+      mjTEXROLE_USER
+    
+      mjTEXROLE_RGB
+    
+      mjTEXROLE_OCCLUSION
+    
+      mjTEXROLE_ROUGHNESS
+    
+      mjTEXROLE_METALLIC
+    
+      mjTEXROLE_NORMAL
+    
+      mjTEXROLE_OPACITY
+    
+      mjTEXROLE_EMISSIVE
+    
+      mjTEXROLE_RGBA
+    
+      mjTEXROLE_ORM
+    
+      mjNTEXROLE
+    """
+    __members__: typing.ClassVar[dict[str, mjtTextureRole]]  # value = {'mjTEXROLE_USER': <mjtTextureRole.mjTEXROLE_USER: 0>, 'mjTEXROLE_RGB': <mjtTextureRole.mjTEXROLE_RGB: 1>, 'mjTEXROLE_OCCLUSION': <mjtTextureRole.mjTEXROLE_OCCLUSION: 2>, 'mjTEXROLE_ROUGHNESS': <mjtTextureRole.mjTEXROLE_ROUGHNESS: 3>, 'mjTEXROLE_METALLIC': <mjtTextureRole.mjTEXROLE_METALLIC: 4>, 'mjTEXROLE_NORMAL': <mjtTextureRole.mjTEXROLE_NORMAL: 5>, 'mjTEXROLE_OPACITY': <mjtTextureRole.mjTEXROLE_OPACITY: 6>, 'mjTEXROLE_EMISSIVE': <mjtTextureRole.mjTEXROLE_EMISSIVE: 7>, 'mjTEXROLE_RGBA': <mjtTextureRole.mjTEXROLE_RGBA: 8>, 'mjTEXROLE_ORM': <mjtTextureRole.mjTEXROLE_ORM: 9>, 'mjNTEXROLE': <mjtTextureRole.mjNTEXROLE: 10>}
+    mjNTEXROLE: typing.ClassVar[mjtTextureRole]  # value = <mjtTextureRole.mjNTEXROLE: 10>
+    mjTEXROLE_EMISSIVE: typing.ClassVar[mjtTextureRole]  # value = <mjtTextureRole.mjTEXROLE_EMISSIVE: 7>
+    mjTEXROLE_METALLIC: typing.ClassVar[mjtTextureRole]  # value = <mjtTextureRole.mjTEXROLE_METALLIC: 4>
+    mjTEXROLE_NORMAL: typing.ClassVar[mjtTextureRole]  # value = <mjtTextureRole.mjTEXROLE_NORMAL: 5>
+    mjTEXROLE_OCCLUSION: typing.ClassVar[mjtTextureRole]  # value = <mjtTextureRole.mjTEXROLE_OCCLUSION: 2>
+    mjTEXROLE_OPACITY: typing.ClassVar[mjtTextureRole]  # value = <mjtTextureRole.mjTEXROLE_OPACITY: 6>
+    mjTEXROLE_ORM: typing.ClassVar[mjtTextureRole]  # value = <mjtTextureRole.mjTEXROLE_ORM: 9>
+    mjTEXROLE_RGB: typing.ClassVar[mjtTextureRole]  # value = <mjtTextureRole.mjTEXROLE_RGB: 1>
+    mjTEXROLE_RGBA: typing.ClassVar[mjtTextureRole]  # value = <mjtTextureRole.mjTEXROLE_RGBA: 8>
+    mjTEXROLE_ROUGHNESS: typing.ClassVar[mjtTextureRole]  # value = <mjtTextureRole.mjTEXROLE_ROUGHNESS: 3>
+    mjTEXROLE_USER: typing.ClassVar[mjtTextureRole]  # value = <mjtTextureRole.mjTEXROLE_USER: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtTimer:
+    """
+    Members:
+    
+      mjTIMER_STEP
+    
+      mjTIMER_FORWARD
+    
+      mjTIMER_INVERSE
+    
+      mjTIMER_POSITION
+    
+      mjTIMER_VELOCITY
+    
+      mjTIMER_ACTUATION
+    
+      mjTIMER_CONSTRAINT
+    
+      mjTIMER_ADVANCE
+    
+      mjTIMER_POS_KINEMATICS
+    
+      mjTIMER_POS_INERTIA
+    
+      mjTIMER_POS_COLLISION
+    
+      mjTIMER_POS_MAKE
+    
+      mjTIMER_POS_PROJECT
+    
+      mjTIMER_COL_BROAD
+    
+      mjTIMER_COL_NARROW
+    
+      mjNTIMER
+    """
+    __members__: typing.ClassVar[dict[str, mjtTimer]]  # value = {'mjTIMER_STEP': <mjtTimer.mjTIMER_STEP: 0>, 'mjTIMER_FORWARD': <mjtTimer.mjTIMER_FORWARD: 1>, 'mjTIMER_INVERSE': <mjtTimer.mjTIMER_INVERSE: 2>, 'mjTIMER_POSITION': <mjtTimer.mjTIMER_POSITION: 3>, 'mjTIMER_VELOCITY': <mjtTimer.mjTIMER_VELOCITY: 4>, 'mjTIMER_ACTUATION': <mjtTimer.mjTIMER_ACTUATION: 5>, 'mjTIMER_CONSTRAINT': <mjtTimer.mjTIMER_CONSTRAINT: 6>, 'mjTIMER_ADVANCE': <mjtTimer.mjTIMER_ADVANCE: 7>, 'mjTIMER_POS_KINEMATICS': <mjtTimer.mjTIMER_POS_KINEMATICS: 8>, 'mjTIMER_POS_INERTIA': <mjtTimer.mjTIMER_POS_INERTIA: 9>, 'mjTIMER_POS_COLLISION': <mjtTimer.mjTIMER_POS_COLLISION: 10>, 'mjTIMER_POS_MAKE': <mjtTimer.mjTIMER_POS_MAKE: 11>, 'mjTIMER_POS_PROJECT': <mjtTimer.mjTIMER_POS_PROJECT: 12>, 'mjTIMER_COL_BROAD': <mjtTimer.mjTIMER_COL_BROAD: 13>, 'mjTIMER_COL_NARROW': <mjtTimer.mjTIMER_COL_NARROW: 14>, 'mjNTIMER': <mjtTimer.mjNTIMER: 15>}
+    mjNTIMER: typing.ClassVar[mjtTimer]  # value = <mjtTimer.mjNTIMER: 15>
+    mjTIMER_ACTUATION: typing.ClassVar[mjtTimer]  # value = <mjtTimer.mjTIMER_ACTUATION: 5>
+    mjTIMER_ADVANCE: typing.ClassVar[mjtTimer]  # value = <mjtTimer.mjTIMER_ADVANCE: 7>
+    mjTIMER_COL_BROAD: typing.ClassVar[mjtTimer]  # value = <mjtTimer.mjTIMER_COL_BROAD: 13>
+    mjTIMER_COL_NARROW: typing.ClassVar[mjtTimer]  # value = <mjtTimer.mjTIMER_COL_NARROW: 14>
+    mjTIMER_CONSTRAINT: typing.ClassVar[mjtTimer]  # value = <mjtTimer.mjTIMER_CONSTRAINT: 6>
+    mjTIMER_FORWARD: typing.ClassVar[mjtTimer]  # value = <mjtTimer.mjTIMER_FORWARD: 1>
+    mjTIMER_INVERSE: typing.ClassVar[mjtTimer]  # value = <mjtTimer.mjTIMER_INVERSE: 2>
+    mjTIMER_POSITION: typing.ClassVar[mjtTimer]  # value = <mjtTimer.mjTIMER_POSITION: 3>
+    mjTIMER_POS_COLLISION: typing.ClassVar[mjtTimer]  # value = <mjtTimer.mjTIMER_POS_COLLISION: 10>
+    mjTIMER_POS_INERTIA: typing.ClassVar[mjtTimer]  # value = <mjtTimer.mjTIMER_POS_INERTIA: 9>
+    mjTIMER_POS_KINEMATICS: typing.ClassVar[mjtTimer]  # value = <mjtTimer.mjTIMER_POS_KINEMATICS: 8>
+    mjTIMER_POS_MAKE: typing.ClassVar[mjtTimer]  # value = <mjtTimer.mjTIMER_POS_MAKE: 11>
+    mjTIMER_POS_PROJECT: typing.ClassVar[mjtTimer]  # value = <mjtTimer.mjTIMER_POS_PROJECT: 12>
+    mjTIMER_STEP: typing.ClassVar[mjtTimer]  # value = <mjtTimer.mjTIMER_STEP: 0>
+    mjTIMER_VELOCITY: typing.ClassVar[mjtTimer]  # value = <mjtTimer.mjTIMER_VELOCITY: 4>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtTrn:
+    """
+    Members:
+    
+      mjTRN_JOINT
+    
+      mjTRN_JOINTINPARENT
+    
+      mjTRN_SLIDERCRANK
+    
+      mjTRN_TENDON
+    
+      mjTRN_SITE
+    
+      mjTRN_BODY
+    
+      mjTRN_SO3
+    
+      mjTRN_UNDEFINED
+    """
+    __members__: typing.ClassVar[dict[str, mjtTrn]]  # value = {'mjTRN_JOINT': <mjtTrn.mjTRN_JOINT: 0>, 'mjTRN_JOINTINPARENT': <mjtTrn.mjTRN_JOINTINPARENT: 1>, 'mjTRN_SLIDERCRANK': <mjtTrn.mjTRN_SLIDERCRANK: 2>, 'mjTRN_TENDON': <mjtTrn.mjTRN_TENDON: 3>, 'mjTRN_SITE': <mjtTrn.mjTRN_SITE: 4>, 'mjTRN_BODY': <mjtTrn.mjTRN_BODY: 5>, 'mjTRN_SO3': <mjtTrn.mjTRN_SO3: 6>, 'mjTRN_UNDEFINED': <mjtTrn.mjTRN_UNDEFINED: 1000>}
+    mjTRN_BODY: typing.ClassVar[mjtTrn]  # value = <mjtTrn.mjTRN_BODY: 5>
+    mjTRN_JOINT: typing.ClassVar[mjtTrn]  # value = <mjtTrn.mjTRN_JOINT: 0>
+    mjTRN_JOINTINPARENT: typing.ClassVar[mjtTrn]  # value = <mjtTrn.mjTRN_JOINTINPARENT: 1>
+    mjTRN_SITE: typing.ClassVar[mjtTrn]  # value = <mjtTrn.mjTRN_SITE: 4>
+    mjTRN_SLIDERCRANK: typing.ClassVar[mjtTrn]  # value = <mjtTrn.mjTRN_SLIDERCRANK: 2>
+    mjTRN_SO3: typing.ClassVar[mjtTrn]  # value = <mjtTrn.mjTRN_SO3: 6>
+    mjTRN_TENDON: typing.ClassVar[mjtTrn]  # value = <mjtTrn.mjTRN_TENDON: 3>
+    mjTRN_UNDEFINED: typing.ClassVar[mjtTrn]  # value = <mjtTrn.mjTRN_UNDEFINED: 1000>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtVisFlag:
+    """
+    Members:
+    
+      mjVIS_CONVEXHULL
+    
+      mjVIS_TEXTURE
+    
+      mjVIS_JOINT
+    
+      mjVIS_CAMERA
+    
+      mjVIS_ACTUATOR
+    
+      mjVIS_ACTIVATION
+    
+      mjVIS_LIGHT
+    
+      mjVIS_TENDON
+    
+      mjVIS_RANGEFINDER
+    
+      mjVIS_CONSTRAINT
+    
+      mjVIS_INERTIA
+    
+      mjVIS_SCLINERTIA
+    
+      mjVIS_PERTFORCE
+    
+      mjVIS_PERTOBJ
+    
+      mjVIS_CONTACTPOINT
+    
+      mjVIS_ISLAND
+    
+      mjVIS_CONTACTFORCE
+    
+      mjVIS_CONTACTSPLIT
+    
+      mjVIS_TRANSPARENT
+    
+      mjVIS_AUTOCONNECT
+    
+      mjVIS_COM
+    
+      mjVIS_SELECT
+    
+      mjVIS_STATIC
+    
+      mjVIS_SKIN
+    
+      mjVIS_FLEXVERT
+    
+      mjVIS_FLEXEDGE
+    
+      mjVIS_FLEXFACE
+    
+      mjVIS_FLEXSKIN
+    
+      mjVIS_BODYBVH
+    
+      mjVIS_MESHBVH
+    
+      mjVIS_SDFITER
+    
+      mjNVISFLAG
+    """
+    __members__: typing.ClassVar[dict[str, mjtVisFlag]]  # value = {'mjVIS_CONVEXHULL': <mjtVisFlag.mjVIS_CONVEXHULL: 0>, 'mjVIS_TEXTURE': <mjtVisFlag.mjVIS_TEXTURE: 1>, 'mjVIS_JOINT': <mjtVisFlag.mjVIS_JOINT: 2>, 'mjVIS_CAMERA': <mjtVisFlag.mjVIS_CAMERA: 3>, 'mjVIS_ACTUATOR': <mjtVisFlag.mjVIS_ACTUATOR: 4>, 'mjVIS_ACTIVATION': <mjtVisFlag.mjVIS_ACTIVATION: 5>, 'mjVIS_LIGHT': <mjtVisFlag.mjVIS_LIGHT: 6>, 'mjVIS_TENDON': <mjtVisFlag.mjVIS_TENDON: 7>, 'mjVIS_RANGEFINDER': <mjtVisFlag.mjVIS_RANGEFINDER: 8>, 'mjVIS_CONSTRAINT': <mjtVisFlag.mjVIS_CONSTRAINT: 9>, 'mjVIS_INERTIA': <mjtVisFlag.mjVIS_INERTIA: 10>, 'mjVIS_SCLINERTIA': <mjtVisFlag.mjVIS_SCLINERTIA: 11>, 'mjVIS_PERTFORCE': <mjtVisFlag.mjVIS_PERTFORCE: 12>, 'mjVIS_PERTOBJ': <mjtVisFlag.mjVIS_PERTOBJ: 13>, 'mjVIS_CONTACTPOINT': <mjtVisFlag.mjVIS_CONTACTPOINT: 14>, 'mjVIS_ISLAND': <mjtVisFlag.mjVIS_ISLAND: 15>, 'mjVIS_CONTACTFORCE': <mjtVisFlag.mjVIS_CONTACTFORCE: 16>, 'mjVIS_CONTACTSPLIT': <mjtVisFlag.mjVIS_CONTACTSPLIT: 17>, 'mjVIS_TRANSPARENT': <mjtVisFlag.mjVIS_TRANSPARENT: 18>, 'mjVIS_AUTOCONNECT': <mjtVisFlag.mjVIS_AUTOCONNECT: 19>, 'mjVIS_COM': <mjtVisFlag.mjVIS_COM: 20>, 'mjVIS_SELECT': <mjtVisFlag.mjVIS_SELECT: 21>, 'mjVIS_STATIC': <mjtVisFlag.mjVIS_STATIC: 22>, 'mjVIS_SKIN': <mjtVisFlag.mjVIS_SKIN: 23>, 'mjVIS_FLEXVERT': <mjtVisFlag.mjVIS_FLEXVERT: 24>, 'mjVIS_FLEXEDGE': <mjtVisFlag.mjVIS_FLEXEDGE: 25>, 'mjVIS_FLEXFACE': <mjtVisFlag.mjVIS_FLEXFACE: 26>, 'mjVIS_FLEXSKIN': <mjtVisFlag.mjVIS_FLEXSKIN: 27>, 'mjVIS_BODYBVH': <mjtVisFlag.mjVIS_BODYBVH: 28>, 'mjVIS_MESHBVH': <mjtVisFlag.mjVIS_MESHBVH: 29>, 'mjVIS_SDFITER': <mjtVisFlag.mjVIS_SDFITER: 30>, 'mjNVISFLAG': <mjtVisFlag.mjNVISFLAG: 31>}
+    mjNVISFLAG: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjNVISFLAG: 31>
+    mjVIS_ACTIVATION: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_ACTIVATION: 5>
+    mjVIS_ACTUATOR: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_ACTUATOR: 4>
+    mjVIS_AUTOCONNECT: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_AUTOCONNECT: 19>
+    mjVIS_BODYBVH: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_BODYBVH: 28>
+    mjVIS_CAMERA: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_CAMERA: 3>
+    mjVIS_COM: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_COM: 20>
+    mjVIS_CONSTRAINT: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_CONSTRAINT: 9>
+    mjVIS_CONTACTFORCE: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_CONTACTFORCE: 16>
+    mjVIS_CONTACTPOINT: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_CONTACTPOINT: 14>
+    mjVIS_CONTACTSPLIT: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_CONTACTSPLIT: 17>
+    mjVIS_CONVEXHULL: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_CONVEXHULL: 0>
+    mjVIS_FLEXEDGE: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_FLEXEDGE: 25>
+    mjVIS_FLEXFACE: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_FLEXFACE: 26>
+    mjVIS_FLEXSKIN: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_FLEXSKIN: 27>
+    mjVIS_FLEXVERT: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_FLEXVERT: 24>
+    mjVIS_INERTIA: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_INERTIA: 10>
+    mjVIS_ISLAND: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_ISLAND: 15>
+    mjVIS_JOINT: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_JOINT: 2>
+    mjVIS_LIGHT: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_LIGHT: 6>
+    mjVIS_MESHBVH: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_MESHBVH: 29>
+    mjVIS_PERTFORCE: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_PERTFORCE: 12>
+    mjVIS_PERTOBJ: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_PERTOBJ: 13>
+    mjVIS_RANGEFINDER: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_RANGEFINDER: 8>
+    mjVIS_SCLINERTIA: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_SCLINERTIA: 11>
+    mjVIS_SDFITER: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_SDFITER: 30>
+    mjVIS_SELECT: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_SELECT: 21>
+    mjVIS_SKIN: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_SKIN: 23>
+    mjVIS_STATIC: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_STATIC: 22>
+    mjVIS_TENDON: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_TENDON: 7>
+    mjVIS_TEXTURE: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_TEXTURE: 1>
+    mjVIS_TRANSPARENT: typing.ClassVar[mjtVisFlag]  # value = <mjtVisFlag.mjVIS_TRANSPARENT: 18>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtWarning:
+    """
+    Members:
+    
+      mjWARN_INERTIA
+    
+      mjWARN_CONTACTFULL
+    
+      mjWARN_CNSTRFULL
+    
+      mjWARN_BADQPOS
+    
+      mjWARN_BADQVEL
+    
+      mjWARN_BADQACC
+    
+      mjWARN_BADCTRL
+    
+      mjNWARNING
+    """
+    __members__: typing.ClassVar[dict[str, mjtWarning]]  # value = {'mjWARN_INERTIA': <mjtWarning.mjWARN_INERTIA: 0>, 'mjWARN_CONTACTFULL': <mjtWarning.mjWARN_CONTACTFULL: 1>, 'mjWARN_CNSTRFULL': <mjtWarning.mjWARN_CNSTRFULL: 2>, 'mjWARN_BADQPOS': <mjtWarning.mjWARN_BADQPOS: 3>, 'mjWARN_BADQVEL': <mjtWarning.mjWARN_BADQVEL: 4>, 'mjWARN_BADQACC': <mjtWarning.mjWARN_BADQACC: 5>, 'mjWARN_BADCTRL': <mjtWarning.mjWARN_BADCTRL: 6>, 'mjNWARNING': <mjtWarning.mjNWARNING: 7>}
+    mjNWARNING: typing.ClassVar[mjtWarning]  # value = <mjtWarning.mjNWARNING: 7>
+    mjWARN_BADCTRL: typing.ClassVar[mjtWarning]  # value = <mjtWarning.mjWARN_BADCTRL: 6>
+    mjWARN_BADQACC: typing.ClassVar[mjtWarning]  # value = <mjtWarning.mjWARN_BADQACC: 5>
+    mjWARN_BADQPOS: typing.ClassVar[mjtWarning]  # value = <mjtWarning.mjWARN_BADQPOS: 3>
+    mjWARN_BADQVEL: typing.ClassVar[mjtWarning]  # value = <mjtWarning.mjWARN_BADQVEL: 4>
+    mjWARN_CNSTRFULL: typing.ClassVar[mjtWarning]  # value = <mjtWarning.mjWARN_CNSTRFULL: 2>
+    mjWARN_CONTACTFULL: typing.ClassVar[mjtWarning]  # value = <mjtWarning.mjWARN_CONTACTFULL: 1>
+    mjWARN_INERTIA: typing.ClassVar[mjtWarning]  # value = <mjtWarning.mjWARN_INERTIA: 0>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class mjtWrap:
+    """
+    Members:
+    
+      mjWRAP_NONE
+    
+      mjWRAP_JOINT
+    
+      mjWRAP_PULLEY
+    
+      mjWRAP_SITE
+    
+      mjWRAP_SPHERE
+    
+      mjWRAP_CYLINDER
+    """
+    __members__: typing.ClassVar[dict[str, mjtWrap]]  # value = {'mjWRAP_NONE': <mjtWrap.mjWRAP_NONE: 0>, 'mjWRAP_JOINT': <mjtWrap.mjWRAP_JOINT: 1>, 'mjWRAP_PULLEY': <mjtWrap.mjWRAP_PULLEY: 2>, 'mjWRAP_SITE': <mjtWrap.mjWRAP_SITE: 3>, 'mjWRAP_SPHERE': <mjtWrap.mjWRAP_SPHERE: 4>, 'mjWRAP_CYLINDER': <mjtWrap.mjWRAP_CYLINDER: 5>}
+    mjWRAP_CYLINDER: typing.ClassVar[mjtWrap]  # value = <mjtWrap.mjWRAP_CYLINDER: 5>
+    mjWRAP_JOINT: typing.ClassVar[mjtWrap]  # value = <mjtWrap.mjWRAP_JOINT: 1>
+    mjWRAP_NONE: typing.ClassVar[mjtWrap]  # value = <mjtWrap.mjWRAP_NONE: 0>
+    mjWRAP_PULLEY: typing.ClassVar[mjtWrap]  # value = <mjtWrap.mjWRAP_PULLEY: 2>
+    mjWRAP_SITE: typing.ClassVar[mjtWrap]  # value = <mjtWrap.mjWRAP_SITE: 3>
+    mjWRAP_SPHERE: typing.ClassVar[mjtWrap]  # value = <mjtWrap.mjWRAP_SPHERE: 4>
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __add__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __and__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __floordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @typing.overload
+    def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __lshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __neg__(self) -> int:
+        ...
+    def __or__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __radd__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rand__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rfloordiv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmod__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rmul__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __ror__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __rshift__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __rsub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rtruediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __rxor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __setstate__(self, state: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @typing.overload
+    def __sub__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __truediv__(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        ...
+    def __xor__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
diff --git a/typings/mujoco/_errors.pyi b/typings/mujoco/_errors.pyi
new file mode 100644
index 0000000..3cd3135
--- /dev/null
+++ b/typings/mujoco/_errors.pyi
@@ -0,0 +1,4 @@
+from __future__ import annotations
+from mujoco import FatalError
+from mujoco import UnexpectedError
+__all__: list[str] = ['FatalError', 'UnexpectedError']
diff --git a/typings/mujoco/_functions.pyi b/typings/mujoco/_functions.pyi
new file mode 100644
index 0000000..517c876
--- /dev/null
+++ b/typings/mujoco/_functions.pyi
@@ -0,0 +1,1095 @@
+from __future__ import annotations
+import mujoco._structs
+import numpy
+import numpy.typing
+import types
+import typing
+__all__: list[str] = ['mj_Euler', 'mj_RungeKutta', 'mj_actuatorInputName', 'mj_addContact', 'mj_addM', 'mj_angmomMat', 'mj_applyFT', 'mj_camlight', 'mj_checkAcc', 'mj_checkPos', 'mj_checkVel', 'mj_clearCache', 'mj_collision', 'mj_comPos', 'mj_comVel', 'mj_compareFwdInv', 'mj_constraintUpdate', 'mj_contactForce', 'mj_copyData', 'mj_copyState', 'mj_crb', 'mj_defaultLROpt', 'mj_defaultOption', 'mj_defaultSolRefImp', 'mj_defaultVisual', 'mj_differentiatePos', 'mj_energyPos', 'mj_energyVel', 'mj_extractState', 'mj_factorM', 'mj_flex', 'mj_forward', 'mj_forwardSkip', 'mj_fullM', 'mj_fwdAcceleration', 'mj_fwdActuation', 'mj_fwdConstraint', 'mj_fwdKinematics', 'mj_fwdPosition', 'mj_fwdVelocity', 'mj_geomDistance', 'mj_getCache', 'mj_getCacheCapacity', 'mj_getCacheSize', 'mj_getState', 'mj_getTotalmass', 'mj_id2name', 'mj_implicit', 'mj_initCtrlHistory', 'mj_initSensorHistory', 'mj_integratePos', 'mj_invConstraint', 'mj_invPosition', 'mj_invVelocity', 'mj_inverse', 'mj_inverseSkip', 'mj_isDual', 'mj_isPyramidal', 'mj_isSparse', 'mj_island', 'mj_jac', 'mj_jacBody', 'mj_jacBodyCom', 'mj_jacDot', 'mj_jacGeom', 'mj_jacPointAxis', 'mj_jacSite', 'mj_jacSubtreeCom', 'mj_kinematics', 'mj_loadAllPluginLibraries', 'mj_loadPluginLibrary', 'mj_local2Global', 'mj_makeConstraint', 'mj_makeM', 'mj_maxContact', 'mj_mulJacTVec', 'mj_mulJacVec', 'mj_mulM', 'mj_mulM2', 'mj_multiRay', 'mj_name2id', 'mj_normalizeQuat', 'mj_objectAcceleration', 'mj_objectVelocity', 'mj_passive', 'mj_printData', 'mj_printFormattedData', 'mj_printFormattedModel', 'mj_printFormattedScene', 'mj_printModel', 'mj_printScene', 'mj_printSchema', 'mj_projectConstraint', 'mj_ray', 'mj_rayFlex', 'mj_rayHfield', 'mj_rayMesh', 'mj_readCtrl', 'mj_readSensor', 'mj_referenceConstraint', 'mj_resetCallbacks', 'mj_resetCtrl', 'mj_resetData', 'mj_resetDataDebug', 'mj_resetDataKeyframe', 'mj_rne', 'mj_rnePostConstraint', 'mj_saveLastXML', 'mj_saveModel', 'mj_sensorAcc', 'mj_sensorPos', 'mj_sensorVel', 'mj_setCacheCapacity', 'mj_setConst', 'mj_setKeyframe', 'mj_setLengthRange', 'mj_setState', 'mj_setTotalmass', 'mj_sizeModel', 'mj_solveM', 'mj_solveM2', 'mj_stateSize', 'mj_step', 'mj_step1', 'mj_step2', 'mj_subtreeVel', 'mj_tendon', 'mj_transmission', 'mj_version', 'mj_versionString', 'mjd_inverseFD', 'mjd_quatIntegrate', 'mjd_subQuat', 'mjd_transitionFD', 'mju_Halton', 'mju_L1', 'mju_add', 'mju_add3', 'mju_addScl', 'mju_addScl3', 'mju_addTo', 'mju_addTo3', 'mju_addToScl', 'mju_addToScl3', 'mju_axisAngle2Quat', 'mju_band2Dense', 'mju_bandDiag', 'mju_bandMulMatVec', 'mju_boxQP', 'mju_cholFactor', 'mju_cholFactorBand', 'mju_cholSolve', 'mju_cholSolveBand', 'mju_cholUpdate', 'mju_clip', 'mju_copy', 'mju_copy3', 'mju_copy4', 'mju_cross', 'mju_d2n', 'mju_decodePyramid', 'mju_dense2Band', 'mju_dense2sparse', 'mju_derivQuat', 'mju_dist3', 'mju_dot', 'mju_dot3', 'mju_eig3', 'mju_encodePyramid', 'mju_euler2Quat', 'mju_eye', 'mju_f2n', 'mju_fill', 'mju_getXMLDependencies', 'mju_insertionSort', 'mju_insertionSortInt', 'mju_isBad', 'mju_isZero', 'mju_mat2Quat', 'mju_mat2Rot', 'mju_max', 'mju_min', 'mju_mulMatMat', 'mju_mulMatMatT', 'mju_mulMatTMat', 'mju_mulMatTVec', 'mju_mulMatTVec3', 'mju_mulMatVec', 'mju_mulMatVec3', 'mju_mulPose', 'mju_mulQuat', 'mju_mulQuatAxis', 'mju_mulVecMatVec', 'mju_muscleBias', 'mju_muscleDynamics', 'mju_muscleGain', 'mju_n2d', 'mju_n2f', 'mju_negPose', 'mju_negQuat', 'mju_norm', 'mju_norm3', 'mju_normalize', 'mju_normalize3', 'mju_normalize4', 'mju_printMat', 'mju_printMatSparse', 'mju_quat2Mat', 'mju_quat2Vel', 'mju_quatIntegrate', 'mju_quatZ2Vec', 'mju_rayGeom', 'mju_raySkin', 'mju_rotVecQuat', 'mju_round', 'mju_scl', 'mju_scl3', 'mju_sigmoid', 'mju_sign', 'mju_sparse2dense', 'mju_springDamper', 'mju_sqrMatTD', 'mju_standardNormal', 'mju_str2Type', 'mju_sub', 'mju_sub3', 'mju_subFrom', 'mju_subFrom3', 'mju_subQuat', 'mju_sum', 'mju_sym2dense', 'mju_symmetrize', 'mju_threadpool', 'mju_transformSpatial', 'mju_transpose', 'mju_trnVecPose', 'mju_type2Str', 'mju_unit4', 'mju_warningText', 'mju_writeLog', 'mju_writeNumBytes', 'mju_zero', 'mju_zero3', 'mju_zero4', 'mjv_addGeoms', 'mjv_alignToCamera', 'mjv_applyPerturbForce', 'mjv_applyPerturbPose', 'mjv_cameraFrame', 'mjv_cameraFrustum', 'mjv_cameraInModel', 'mjv_cameraInRoom', 'mjv_connector', 'mjv_defaultCamera', 'mjv_defaultFigure', 'mjv_defaultFreeCamera', 'mjv_defaultOption', 'mjv_defaultPerturb', 'mjv_frustumHeight', 'mjv_initGeom', 'mjv_initPerturb', 'mjv_makeLights', 'mjv_model2room', 'mjv_moveCamera', 'mjv_moveModel', 'mjv_movePerturb', 'mjv_room2model', 'mjv_select', 'mjv_updateCamera', 'mjv_updateScene', 'mjv_updateSkin']
+def _realloc_con_efc(d: mujoco._structs.MjData, ncon: typing.SupportsInt | typing.SupportsIndex, nefc: typing.SupportsInt | typing.SupportsIndex, nJ: typing.SupportsInt | typing.SupportsIndex = -1) -> None:
+    ...
+def _realloc_island(d: mujoco._structs.MjData, nisland: typing.SupportsInt | typing.SupportsIndex, nidof: typing.SupportsInt | typing.SupportsIndex) -> None:
+    ...
+def mj_Euler(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Euler integrator, semi-implicit in velocity.
+    """
+def mj_RungeKutta(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, N: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Runge-Kutta explicit order-N integrator.
+    """
+def mj_actuatorInputName(m: mujoco._structs.MjModel, id: typing.SupportsInt | typing.SupportsIndex, input: typing.SupportsInt | typing.SupportsIndex) -> str:
+    """
+    Get name of actuator input, determined by the actuator type and input signature; return NULL if the actuator type defines no input names.
+    """
+def mj_addContact(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, con: mujoco._structs.MjContact) -> int:
+    """
+    Add contact to d->contact list; return 0 if success; 1 if buffer full.
+    """
+def mj_addM(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, dst: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], rownnz: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]", "flags.writeable"], rowadr: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]", "flags.writeable"], colind: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]", "flags.writeable"]) -> None:
+    """
+    Add inertia matrix to destination matrix (lower triangle only). Destination can be sparse or dense when all int* are NULL.
+    """
+def mj_angmomMat(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"], body: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Compute subtree angular momentum matrix.
+    """
+def mj_applyFT(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, force: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], torque: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], point: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], body: typing.SupportsInt | typing.SupportsIndex, qfrc_target: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"]) -> None:
+    """
+    Apply Cartesian force and torque (outside xfrc_applied mechanism).
+    """
+def mj_camlight(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Compute camera and light positions and orientations.
+    """
+def mj_checkAcc(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Check qacc, reset if any element is too big or nan.
+    """
+def mj_checkPos(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Check qpos, reset if any element is too big or nan.
+    """
+def mj_checkVel(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Check qvel, reset if any element is too big or nan.
+    """
+def mj_clearCache(cache: types.CapsuleType) -> None:
+    """
+    Clear the asset cache.
+    """
+def mj_collision(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Run collision detection.
+    """
+def mj_comPos(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Map inertias and motion dofs to global frame centered at CoM.
+    """
+def mj_comVel(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Compute cvel, cdof_dot.
+    """
+def mj_compareFwdInv(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Compare forward and inverse dynamics, save results in fwdinv.
+    """
+def mj_constraintUpdate(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, jar: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], cost: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[1, 1]", "flags.writeable"] | None, flg_coneHessian: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Compute efc_state, efc_force, qfrc_constraint, and (optionally) cone Hessians. If cost is not NULL, set *cost = s(jar) where jar = Jac*qacc-aref.
+    """
+def mj_contactForce(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, id: typing.SupportsInt | typing.SupportsIndex, result: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]", "flags.writeable"]) -> None:
+    """
+    Extract 6D force:torque given contact id, in the contact frame.
+    """
+def mj_copyData(dest: mujoco._structs.MjData, m: mujoco._structs.MjModel, src: mujoco._structs.MjData) -> None:
+    """
+    Copy mjData. m is only required to contain the size fields from MJMODEL_INTS.
+    """
+def mj_copyState(m: mujoco._structs.MjModel, src: mujoco._structs.MjData, dst: mujoco._structs.MjData, sig: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Copy state from src to dst.
+    """
+def mj_crb(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Run composite rigid body inertia algorithm (CRB).
+    """
+def mj_defaultLROpt(opt: mujoco._structs.MjLROpt) -> None:
+    """
+    Set default options for length range computation.
+    """
+def mj_defaultOption(opt: mujoco._structs.MjOption) -> None:
+    """
+    Set physics options to default values.
+    """
+def mj_defaultSolRefImp(solref: typing.SupportsFloat | typing.SupportsIndex, solimp: typing.SupportsFloat | typing.SupportsIndex) -> None:
+    """
+    Set solver parameters to default values.
+    """
+def mj_defaultVisual(vis: mujoco._structs.MjVisual) -> None:
+    """
+    Set visual options to default values.
+    """
+def mj_differentiatePos(m: mujoco._structs.MjModel, qvel: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], dt: typing.SupportsFloat | typing.SupportsIndex, qpos1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], qpos2: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Compute velocity by finite-differencing two positions.
+    """
+def mj_energyPos(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Evaluate position-dependent energy (potential).
+    """
+def mj_energyVel(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Evaluate velocity-dependent energy (kinetic).
+    """
+def mj_extractState(m: mujoco._structs.MjModel, src: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], srcsig: typing.SupportsInt | typing.SupportsIndex, dst: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], dstsig: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Extract a subset of components from a state previously obtained via mj_getState.
+    """
+def mj_factorM(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Compute sparse L'*D*L factorizaton of inertia matrix.
+    """
+def mj_flex(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Compute flex-related quantities.
+    """
+def mj_forward(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Forward dynamics: same as mj_step but do not integrate in time.
+    """
+def mj_forwardSkip(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, skipstage: typing.SupportsInt | typing.SupportsIndex, skipsensor: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Forward dynamics with skip; skipstage is mjtStage.
+    """
+def mj_fullM(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, dst: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"]) -> None:
+    """
+    Convert sparse inertia matrix into full (i.e. dense) matrix.
+    """
+def mj_fwdAcceleration(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Add up all non-constraint forces, compute qacc_smooth.
+    """
+def mj_fwdActuation(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Compute actuator force qfrc_actuator.
+    """
+def mj_fwdConstraint(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Run selected constraint solver.
+    """
+def mj_fwdKinematics(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Run all kinematics-like computations (kinematics, comPos, camlight, flex, tendon).
+    """
+def mj_fwdPosition(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Run position-dependent computations.
+    """
+def mj_fwdVelocity(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Run velocity-dependent computations.
+    """
+def mj_geomDistance(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, geom1: typing.SupportsInt | typing.SupportsIndex, geom2: typing.SupportsInt | typing.SupportsIndex, distmax: typing.SupportsFloat | typing.SupportsIndex, fromto: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None) -> float:
+    """
+    Return smallest signed distance between two geoms and optionally segment from geom1 to geom2.
+    """
+def mj_getCache() -> types.CapsuleType:
+    """
+    Get the internal asset cache used by the compiler.
+    """
+def mj_getCacheCapacity(cache: types.CapsuleType) -> int:
+    """
+    Get the capacity of the asset cache in bytes.
+    """
+def mj_getCacheSize(cache: types.CapsuleType) -> int:
+    """
+    Get the current size of the asset cache in bytes.
+    """
+def mj_getState(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, state: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], sig: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Get state.
+    """
+def mj_getTotalmass(m: mujoco._structs.MjModel) -> float:
+    """
+    Sum all body masses.
+    """
+def mj_id2name(m: mujoco._structs.MjModel, type: typing.SupportsInt | typing.SupportsIndex, id: typing.SupportsInt | typing.SupportsIndex) -> str:
+    """
+    Get name of object with the specified mjtObj type and id; return NULL if name not found.
+    """
+def mj_implicit(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Implicit-in-velocity integrators.
+    """
+def mj_initCtrlHistory(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, id: typing.SupportsInt | typing.SupportsIndex, times: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"] | None, values: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Initialize history buffer for actuator; if times is NULL, uses existing buffer timestamps.
+    """
+def mj_initSensorHistory(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, id: typing.SupportsInt | typing.SupportsIndex, times: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"] | None, values: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"], phase: typing.SupportsFloat | typing.SupportsIndex) -> None:
+    """
+    Initialize history buffer for sensor; if times is NULL, uses existing buffer timestamps. phase sets the user slot (last computation time for interval sensors).
+    """
+def mj_integratePos(m: mujoco._structs.MjModel, qpos: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], qvel: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], dt: typing.SupportsFloat | typing.SupportsIndex) -> None:
+    """
+    Integrate position with given velocity.
+    """
+def mj_invConstraint(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Apply the analytical formula for inverse constraint dynamics.
+    """
+def mj_invPosition(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Run position-dependent computations in inverse dynamics.
+    """
+def mj_invVelocity(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Run velocity-dependent computations in inverse dynamics.
+    """
+def mj_inverse(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Inverse dynamics: qacc must be set before calling.
+    """
+def mj_inverseSkip(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, skipstage: typing.SupportsInt | typing.SupportsIndex, skipsensor: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Inverse dynamics with skip; skipstage is mjtStage.
+    """
+def mj_isDual(m: mujoco._structs.MjModel) -> int:
+    """
+    Determine type of solver (PGS is dual, CG and Newton are primal).
+    """
+def mj_isPyramidal(m: mujoco._structs.MjModel) -> int:
+    """
+    Determine type of friction cone.
+    """
+def mj_isSparse(m: mujoco._structs.MjModel) -> int:
+    """
+    Determine type of constraint Jacobian.
+    """
+def mj_island(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Find constraint islands.
+    """
+def mj_jac(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, jacp: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, jacr: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, point: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], body: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Compute 3/6-by-nv end-effector Jacobian of global point attached to given body.
+    """
+def mj_jacBody(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, jacp: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, jacr: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, body: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Compute body frame end-effector Jacobian.
+    """
+def mj_jacBodyCom(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, jacp: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, jacr: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, body: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Compute body center-of-mass end-effector Jacobian.
+    """
+def mj_jacDot(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, jacp: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, jacr: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, point: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], body: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Compute 3/6-by-nv Jacobian time derivative of global point attached to given body.
+    """
+def mj_jacGeom(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, jacp: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, jacr: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, geom: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Compute geom end-effector Jacobian.
+    """
+def mj_jacPointAxis(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, jacPoint: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, jacAxis: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, point: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], axis: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], body: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Compute translation end-effector Jacobian of point, and rotation Jacobian of axis.
+    """
+def mj_jacSite(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, jacp: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, jacr: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, site: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Compute site end-effector Jacobian.
+    """
+def mj_jacSubtreeCom(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, jacp: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, body: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Compute subtree center-of-mass end-effector Jacobian.
+    """
+def mj_kinematics(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Run forward kinematics.
+    """
+def mj_loadAllPluginLibraries(directory: str) -> None:
+    """
+    Scan a directory and load all dynamic libraries. Dynamic libraries in the specified directory are assumed to register one or more plugins. Optionally, if a callback is specified, it is called for each dynamic library encountered that registers plugins.
+    """
+def mj_loadPluginLibrary(path: str) -> None:
+    """
+    Load a dynamic library. The dynamic library is assumed to register one or more plugins.
+    """
+def mj_local2Global(d: mujoco._structs.MjData, xpos: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], xmat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[9, 1]", "flags.writeable"], pos: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], quat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"], body: typing.SupportsInt | typing.SupportsIndex, sameframe: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Map from body local to global Cartesian coordinates, sameframe takes values from mjtSameFrame.
+    """
+def mj_makeConstraint(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Construct constraints.
+    """
+def mj_makeM(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Make inertia matrix.
+    """
+def mj_maxContact(m: mujoco._structs.MjModel, g1: typing.SupportsInt | typing.SupportsIndex, g2: typing.SupportsInt | typing.SupportsIndex, has_margin: typing.SupportsInt | typing.SupportsIndex) -> int:
+    """
+    Return the maximum number of contacts that can be generated between two geoms. If has_margin is -1, then the margin is pulled from the model, otherwise if has_margin > 0 indicates that the geoms have a positive margin.
+    """
+def mj_mulJacTVec(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Multiply dense or sparse constraint Jacobian transpose by vector.
+    """
+def mj_mulJacVec(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Multiply dense or sparse constraint Jacobian by vector.
+    """
+def mj_mulM(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Multiply vector by inertia matrix.
+    """
+def mj_mulM2(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Multiply vector by (inertia matrix)^(1/2).
+    """
+def mj_multiRay(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, pnt: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], geomgroup: typing.Annotated[numpy.typing.NDArray[numpy.uint8], "[6, 1]"] | None, flg_static: bool, bodyexclude: typing.SupportsInt | typing.SupportsIndex, geomid: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]", "flags.writeable"], dist: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], normal: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"] | None, nray: typing.SupportsInt | typing.SupportsIndex, cutoff: typing.SupportsFloat | typing.SupportsIndex) -> None:
+    """
+    Intersect multiple rays emanating from a single point, compute normals if given. Similar semantics to mj_ray, but vec, normal and dist are arrays. Geoms further than cutoff are ignored.
+    """
+def mj_name2id(m: mujoco._structs.MjModel, type: typing.SupportsInt | typing.SupportsIndex, name: str) -> int:
+    """
+    Get id of object with the specified mjtObj type and name; return -1 if id not found.
+    """
+def mj_normalizeQuat(m: mujoco._structs.MjModel, qpos: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"]) -> None:
+    """
+    Normalize all quaternions in qpos-type vector.
+    """
+def mj_objectAcceleration(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, objtype: typing.SupportsInt | typing.SupportsIndex, objid: typing.SupportsInt | typing.SupportsIndex, res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]", "flags.writeable"], flg_local: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Compute object 6D acceleration (rot:lin) in object-centered frame, world/local orientation.
+    """
+def mj_objectVelocity(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, objtype: typing.SupportsInt | typing.SupportsIndex, objid: typing.SupportsInt | typing.SupportsIndex, res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]", "flags.writeable"], flg_local: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Compute object 6D velocity (rot:lin) in object-centered frame, world/local orientation.
+    """
+def mj_passive(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Compute qfrc_passive from spring-dampers, gravity compensation and fluid forces.
+    """
+def mj_printData(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, filename: str) -> None:
+    """
+    Print data to text file.
+    """
+def mj_printFormattedData(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, filename: str, float_format: str) -> None:
+    """
+    Print mjData to text file, specifying format. float_format must be a valid printf-style format string for a single float value.
+    """
+def mj_printFormattedModel(m: mujoco._structs.MjModel, filename: str, float_format: str) -> None:
+    """
+    Print mjModel to text file, specifying format. float_format must be a valid printf-style format string for a single float value.
+    """
+def mj_printFormattedScene(s: mujoco._structs.MjvScene, filename: str, float_format: str) -> None:
+    """
+    Print scene to text file, specifying format. float_format must be a valid printf-style format string for a single float value.
+    """
+def mj_printModel(m: mujoco._structs.MjModel, filename: str) -> None:
+    """
+    Print model to text file.
+    """
+def mj_printScene(s: mujoco._structs.MjvScene, filename: str) -> None:
+    """
+    Print scene to text file.
+    """
+def mj_printSchema(flg_html: bool, flg_pad: bool) -> str:
+    """
+    Print internal XML schema as plain text or HTML, with style-padding or &nbsp;.
+    """
+def mj_projectConstraint(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Compute inverse constraint inertia efc_AR.
+    """
+def mj_ray(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, pnt: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], geomgroup: typing.Annotated[numpy.typing.NDArray[numpy.uint8], "[6, 1]"] | None, flg_static: bool, bodyexclude: typing.SupportsInt | typing.SupportsIndex, geomid: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[1, 1]", "flags.writeable"] | None, normal: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"] | None = None) -> float:
+    """
+    Intersect ray (pnt+x*vec, x>=0) with visible geoms, except geoms in bodyexclude. Return distance (x) to nearest surface, or -1 if no intersection. geomgroup, flg_static are as in mjvOption; geomgroup==NULL skips group exclusion.
+    """
+def mj_rayFlex(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, flex_layer: typing.SupportsInt | typing.SupportsIndex, flg_vert: bool, flg_edge: bool, flg_face: bool, flg_skin: bool, flexid: typing.SupportsInt | typing.SupportsIndex, pnt: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], vertid: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[1, 1]", "flags.writeable"] | None = None, normal: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"] | None = None) -> float:
+    """
+    Intersect ray with flex; return nearest distance or -1 if no intersection, and also output nearest vertex id and surface normal.
+    """
+def mj_rayHfield(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, geomid: typing.SupportsInt | typing.SupportsIndex, pnt: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], normal: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"] | None = None) -> float:
+    """
+    Intersect ray with hfield; return nearest distance or -1 if no intersection.
+    """
+def mj_rayMesh(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, geomid: typing.SupportsInt | typing.SupportsIndex, pnt: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], normal: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"] | None = None) -> float:
+    """
+    Intersect ray with mesh; return nearest distance or -1 if no intersection.
+    """
+def mj_readCtrl(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, id: typing.SupportsInt | typing.SupportsIndex, time: typing.SupportsFloat | typing.SupportsIndex, interp: typing.SupportsInt | typing.SupportsIndex) -> float:
+    """
+    Read ctrl value for actuator at given time. Returns d->ctrl[id] if no history, otherwise reads from history buffer. interp: 0=zero-order-hold, 1=linear, 2=cubic spline.
+    """
+def mj_readSensor(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, id: typing.SupportsInt | typing.SupportsIndex, time: typing.SupportsFloat | typing.SupportsIndex, result: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], interp: typing.SupportsInt | typing.SupportsIndex) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"]:
+    """
+    Read sensor value from history buffer at given time. Returns pointer to sensordata (no history) or history buffer (exact match), or NULL if interpolation performed (writes to result). interp: 0=zero-order-hold, 1=linear, 2=cubic spline.
+    """
+def mj_referenceConstraint(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Compute efc_vel, efc_aref.
+    """
+def mj_resetCallbacks() -> None:
+    """
+    Reset all callbacks to NULL pointers (NULL is the default).
+    """
+def mj_resetCtrl(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Reset ctrl to neutral values: zero, except quaternion inputs which reset to the identity.
+    """
+def mj_resetData(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Reset data to defaults.
+    """
+def mj_resetDataDebug(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, debug_value: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Reset data to defaults, fill everything else with debug_value.
+    """
+def mj_resetDataKeyframe(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, key: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Reset data. If 0 <= key < nkey, set fields from specified keyframe.
+    """
+def mj_rne(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, flg_acc: typing.SupportsInt | typing.SupportsIndex, result: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"]) -> None:
+    """
+    RNE: compute M(qpos)*qacc + C(qpos,qvel); flg_acc=0 removes inertial term.
+    """
+def mj_rnePostConstraint(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    RNE with complete data: compute cacc, cfrc_ext, cfrc_int.
+    """
+def mj_saveLastXML(filename: str, m: mujoco._structs.MjModel) -> None:
+    """
+    Update XML data structures with info from low-level model created with mj_loadXML, save as MJCF. If error is not NULL, it must have size error_sz.
+    """
+def mj_saveModel(m: mujoco._structs.MjModel, filename: str | None = None, buffer: typing.Annotated[numpy.typing.NDArray[numpy.uint8], "[m, 1]", "flags.writeable"] | None = None) -> None:
+    """
+    Save model to binary MJB file or memory buffer; buffer has precedence when given.
+    """
+def mj_sensorAcc(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Evaluate acceleration and force-dependent sensors.
+    """
+def mj_sensorPos(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Evaluate position-dependent sensors.
+    """
+def mj_sensorVel(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Evaluate velocity-dependent sensors.
+    """
+def mj_setCacheCapacity(cache: types.CapsuleType, size: typing.SupportsInt | typing.SupportsIndex) -> int:
+    """
+    Set the capacity of the asset cache in bytes (0 to disable); return the new capacity.
+    """
+def mj_setConst(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Set constant fields of mjModel, corresponding to qpos0 configuration.
+    """
+def mj_setKeyframe(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, k: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Copy current state to the k-th model keyframe.
+    """
+def mj_setLengthRange(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, index: typing.SupportsInt | typing.SupportsIndex, opt: mujoco._structs.MjLROpt) -> None:
+    """
+    Set actuator_lengthrange for specified actuator; return 1 if ok, 0 if error.
+    """
+def mj_setState(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, state: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], sig: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Set state.
+    """
+def mj_setTotalmass(m: mujoco._structs.MjModel, newmass: typing.SupportsFloat | typing.SupportsIndex) -> None:
+    """
+    Scale body masses and inertias to achieve specified total mass.
+    """
+def mj_sizeModel(m: mujoco._structs.MjModel) -> int:
+    """
+    Return size of buffer needed to hold model.
+    """
+def mj_solveM(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, x: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"], y: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"]) -> None:
+    """
+    Solve linear system M * x = y using factorization:  x = inv(L'*D*L)*y
+    """
+def mj_solveM2(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, x: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"], y: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"], sqrtInvD: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"]) -> None:
+    """
+    Half of linear solve:  x = sqrt(inv(D))*inv(L')*y
+    """
+def mj_stateSize(m: mujoco._structs.MjModel, sig: typing.SupportsInt | typing.SupportsIndex) -> int:
+    """
+    Return size of state signature.
+    """
+def mj_step(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, nstep: typing.SupportsInt | typing.SupportsIndex = 1) -> None:
+    """
+    Advance simulation, use control callback to obtain external force and control. Optionally, repeat nstep times.
+    """
+def mj_step1(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Advance simulation in two steps: before external force and control is set by user.
+    """
+def mj_step2(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Advance simulation in two steps: after external force and control is set by user.
+    """
+def mj_subtreeVel(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Sub-tree linear velocity and angular momentum: compute subtree_linvel, subtree_angmom.
+    """
+def mj_tendon(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Compute tendon lengths, velocities and moment arms.
+    """
+def mj_transmission(m: mujoco._structs.MjModel, d: mujoco._structs.MjData) -> None:
+    """
+    Compute actuator transmission lengths and moments.
+    """
+def mj_version() -> int:
+    """
+    Return version number: 1.0.2 is encoded as 102.
+    """
+def mj_versionString() -> str:
+    """
+    Return the current version of MuJoCo as a null-terminated string.
+    """
+def mjd_inverseFD(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, eps: typing.SupportsFloat | typing.SupportsIndex, flg_actuation: bool, DfDq: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, DfDv: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, DfDa: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, DsDq: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, DsDv: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, DsDa: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, DmDq: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None) -> None:
+    """
+    Finite differenced Jacobians of (force, sensors) = mj_inverse(state, acceleration)   All outputs are optional. Output dimensions (transposed w.r.t Control Theory convention):     DfDq: (nv x nv)     DfDv: (nv x nv)     DfDa: (nv x nv)     DsDq: (nv x nsensordata)     DsDv: (nv x nsensordata)     DsDa: (nv x nsensordata)     DmDq: (nv x nC)   single-letter shortcuts:     inputs: q=qpos, v=qvel, a=qacc     outputs: f=qfrc_inverse, s=sensordata, m=M   notes:     optionally computes mass matrix Jacobian DmDq     flg_actuation specifies whether to subtract qfrc_actuator from qfrc_inverse
+    """
+def mjd_quatIntegrate(vel: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], scale: typing.SupportsFloat | typing.SupportsIndex, Dquat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[9, 1]", "flags.writeable"], Dvel: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[9, 1]", "flags.writeable"], Dscale: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]) -> None:
+    """
+    Derivatives of mju_quatIntegrate.
+    """
+def mjd_subQuat(qa: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], qb: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], Da: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, Db: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None) -> None:
+    """
+    Derivatives of mju_subQuat.
+    """
+def mjd_transitionFD(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, eps: typing.SupportsFloat | typing.SupportsIndex, flg_centered: bool, A: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, B: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, C: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None, D: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"] | None) -> None:
+    """
+    Finite differenced transition matrices (control theory notation)   d(x_next) = A*dx + B*du   d(sensor) = C*dx + D*du   required output matrix dimensions:      A: (2*nv+na x 2*nv+na)      B: (2*nv+na x nu)      D: (nsensordata x 2*nv+na)      C: (nsensordata x nu)
+    """
+def mju_Halton(index: typing.SupportsInt | typing.SupportsIndex, base: typing.SupportsInt | typing.SupportsIndex) -> float:
+    """
+    Generate Halton sequence.
+    """
+def mju_L1(vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"]) -> float:
+    """
+    Return L1 norm: sum(abs(vec)).
+    """
+def mju_add(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], vec1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], vec2: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Set res = vec1 + vec2.
+    """
+def mju_add3(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], vec1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], vec2: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+    """
+    Set res = vec1 + vec2.
+    """
+def mju_addScl(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], vec1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], vec2: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], scl: typing.SupportsFloat | typing.SupportsIndex) -> None:
+    """
+    Set res = vec1 + vec2*scl.
+    """
+def mju_addScl3(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], vec1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], vec2: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], scl: typing.SupportsFloat | typing.SupportsIndex) -> None:
+    """
+    Set res = vec1 + vec2*scl.
+    """
+def mju_addTo(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Set res = res + vec.
+    """
+def mju_addTo3(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+    """
+    Set res = res + vec.
+    """
+def mju_addToScl(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], scl: typing.SupportsFloat | typing.SupportsIndex) -> None:
+    """
+    Set res = res + vec*scl.
+    """
+def mju_addToScl3(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], scl: typing.SupportsFloat | typing.SupportsIndex) -> None:
+    """
+    Set res = res + vec*scl.
+    """
+def mju_axisAngle2Quat(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"], axis: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], angle: typing.SupportsFloat | typing.SupportsIndex) -> None:
+    """
+    Convert axisAngle to quaternion.
+    """
+def mju_band2Dense(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], ntotal: typing.SupportsInt | typing.SupportsIndex, nband: typing.SupportsInt | typing.SupportsIndex, ndense: typing.SupportsInt | typing.SupportsIndex, flg_sym: bool) -> None:
+    """
+    Convert banded matrix to dense matrix, fill upper triangle if flg_sym>0.
+    """
+def mju_bandDiag(i: typing.SupportsInt | typing.SupportsIndex, ntotal: typing.SupportsInt | typing.SupportsIndex, nband: typing.SupportsInt | typing.SupportsIndex, ndense: typing.SupportsInt | typing.SupportsIndex) -> int:
+    """
+    Address of diagonal element i in band-dense matrix representation.
+    """
+def mju_bandMulMatVec(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"], ntotal: typing.SupportsInt | typing.SupportsIndex, nband: typing.SupportsInt | typing.SupportsIndex, ndense: typing.SupportsInt | typing.SupportsIndex, nvec: typing.SupportsInt | typing.SupportsIndex, flg_sym: bool) -> None:
+    """
+    Multiply band-diagonal matrix with nvec vectors, include upper triangle if flg_sym>0.
+    """
+def mju_boxQP(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], R: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"], index: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]", "flags.writeable"] | None, H: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"], g: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], lower: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"] | None, upper: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"] | None) -> int:
+    """
+    minimize 0.5*x'*H*x + x'*g  s.t. lower <= x <= upper; return rank or -1 if failed   inputs:     n           - problem dimension     H           - SPD matrix                n*n     g           - bias vector               n     lower       - lower bounds              n     upper       - upper bounds              n     res         - solution warmstart        n   return value:     nfree <= n  - rank of unconstrained subspace, -1 if failure   outputs (required):     res         - solution                  n     R           - subspace Cholesky factor  nfree*nfree    allocated: n*(n+7)   outputs (optional):     index       - set of free dimensions    nfree          allocated: n   notes:     the initial value of res is used to warmstart the solver     R must have allocatd size n*(n+7), but only nfree*nfree values are used in output     index (if given) must have allocated size n, but only nfree values are used in output     only the lower triangles of H and R and are read from and written to, respectively     the convenience function mju_boxQPmalloc allocates the required data structures
+    """
+def mju_cholFactor(mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"], mindiag: typing.SupportsFloat | typing.SupportsIndex) -> int:
+    """
+    Cholesky decomposition: mat = L*L'; return rank, decomposition performed in-place into mat.
+    """
+def mju_cholFactorBand(mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], ntotal: typing.SupportsInt | typing.SupportsIndex, nband: typing.SupportsInt | typing.SupportsIndex, ndense: typing.SupportsInt | typing.SupportsIndex, diagadd: typing.SupportsFloat | typing.SupportsIndex, diagmul: typing.SupportsFloat | typing.SupportsIndex) -> float:
+    """
+    Band-dense Cholesky decomposition.  Return minimum value in the factorized diagonal, or 0 if rank-deficient.  mat has (ntotal-ndense) x nband + ndense x ntotal elements.  The first (ntotal-ndense) x nband store the band part, left of diagonal, inclusive.  The second ndense x ntotal store the band part as entire dense rows.  Add diagadd+diagmul*mat_ii to diagonal before factorization.
+    """
+def mju_cholSolve(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Solve (mat*mat') * res = vec, where mat is a Cholesky factor.
+    """
+def mju_cholSolveBand(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], ntotal: typing.SupportsInt | typing.SupportsIndex, nband: typing.SupportsInt | typing.SupportsIndex, ndense: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Solve (mat*mat')*res = vec where mat is a band-dense Cholesky factor.
+    """
+def mju_cholUpdate(mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"], x: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], flg_plus: typing.SupportsInt | typing.SupportsIndex) -> int:
+    """
+    Cholesky rank-one update: L*L' +/- x*x'; return rank.
+    """
+def mju_clip(x: typing.SupportsFloat | typing.SupportsIndex, min: typing.SupportsFloat | typing.SupportsIndex, max: typing.SupportsFloat | typing.SupportsIndex) -> float:
+    """
+    Clip x to the range [min, max].
+    """
+def mju_copy(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Set res = vec.
+    """
+def mju_copy3(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], data: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+    """
+    Set res = vec.
+    """
+def mju_copy4(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"], data: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"]) -> None:
+    """
+    Set res = vec.
+    """
+def mju_cross(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], a: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], b: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+    """
+    Compute cross-product: res = cross(a, b).
+    """
+def mju_d2n(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Convert from double to mjtNum.
+    """
+def mju_decodePyramid(force: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], pyramid: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], mu: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Convert pyramid representation to contact force.
+    """
+def mju_dense2Band(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"], ntotal: typing.SupportsInt | typing.SupportsIndex, nband: typing.SupportsInt | typing.SupportsIndex, ndense: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Convert dense matrix to banded matrix.
+    """
+def mju_dense2sparse(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"], rownnz: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]", "flags.writeable"], rowadr: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]", "flags.writeable"], colind: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]", "flags.writeable"]) -> int:
+    """
+    Convert matrix from dense to sparse.  nnz is size of res and colind; return 1 if too small, 0 otherwise.
+    """
+def mju_derivQuat(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"], quat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"], vel: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+    """
+    Compute time-derivative of quaternion, given 3D rotational velocity.
+    """
+def mju_dist3(pos1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], pos2: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> float:
+    """
+    Return Cartesian distance between 3D vectors pos1 and pos2.
+    """
+def mju_dot(vec1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], vec2: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> float:
+    """
+    Return dot-product of vec1 and vec2.
+    """
+def mju_dot3(vec1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], vec2: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> float:
+    """
+    Return dot-product of vec1 and vec2.
+    """
+def mju_eig3(eigval: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], eigvec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[9, 1]", "flags.writeable"], quat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[9, 1]"]) -> int:
+    """
+    Eigenvalue decomposition of symmetric 3x3 matrix, mat = eigvec * diag(eigval) * eigvec'.
+    """
+def mju_encodePyramid(pyramid: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], force: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], mu: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Convert contact force to pyramid representation.
+    """
+def mju_euler2Quat(quat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"], euler: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], seq: str) -> None:
+    """
+    Convert sequence of Euler angles (radians) to quaternion. seq[0,1,2] must be in 'xyzXYZ', lower/upper-case mean intrinsic/extrinsic rotations.
+    """
+def mju_eye(mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"]) -> None:
+    """
+    Set mat to the identity matrix.
+    """
+def mju_f2n(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, 1]"]) -> None:
+    """
+    Convert from float to mjtNum.
+    """
+def mju_fill(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], val: typing.SupportsFloat | typing.SupportsIndex) -> None:
+    """
+    Set res = val.
+    """
+def mju_getXMLDependencies(filename: str) -> list[str]:
+    """
+    Given MJCF filename, fills dependencies with a list of all other asset files it depends on. The search is recursive, and the list includes the filename itself.
+    """
+def mju_insertionSort(list: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"]) -> None:
+    """
+    Insertion sort, resulting list is in increasing order.
+    """
+def mju_insertionSortInt(list: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]", "flags.writeable"]) -> None:
+    """
+    Integer insertion sort, resulting list is in increasing order.
+    """
+def mju_isBad(x: typing.SupportsFloat | typing.SupportsIndex) -> int:
+    """
+    Return 1 if nan or abs(x)>mjMAXVAL, 0 otherwise. Used by check functions.
+    """
+def mju_isZero(vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"]) -> int:
+    """
+    Return 1 if all elements are 0.
+    """
+def mju_mat2Quat(quat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[9, 1]"]) -> None:
+    """
+    Convert 3D rotation matrix to quaternion.
+    """
+def mju_mat2Rot(quat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[9, 1]"]) -> int:
+    """
+    Extract 3D rotation from an arbitrary 3x3 matrix by refining the input quaternion. Return the number of iterations required to converge.
+    """
+def mju_max(a: typing.SupportsFloat | typing.SupportsIndex, b: typing.SupportsFloat | typing.SupportsIndex) -> float:
+    """
+    Return max(a,b) with single evaluation of a and b.
+    """
+def mju_min(a: typing.SupportsFloat | typing.SupportsIndex, b: typing.SupportsFloat | typing.SupportsIndex) -> float:
+    """
+    Return min(a,b) with single evaluation of a and b.
+    """
+def mju_mulMatMat(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"], mat1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"], mat2: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"]) -> None:
+    """
+    Multiply matrices: res = mat1 * mat2.
+    """
+def mju_mulMatMatT(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"], mat1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"], mat2: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"]) -> None:
+    """
+    Multiply matrices, second argument transposed: res = mat1 * mat2'.
+    """
+def mju_mulMatTMat(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"], mat1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"], mat2: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"]) -> None:
+    """
+    Multiply matrices, first argument transposed: res = mat1' * mat2.
+    """
+def mju_mulMatTVec(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Multiply transposed matrix and vector: res = mat' * vec.
+    """
+def mju_mulMatTVec3(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[9, 1]"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+    """
+    Multiply transposed 3-by-3 matrix by vector: res = mat' * vec.
+    """
+def mju_mulMatVec(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Multiply matrix and vector: res = mat * vec.
+    """
+def mju_mulMatVec3(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[9, 1]"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+    """
+    Multiply 3-by-3 matrix by vector: res = mat * vec.
+    """
+def mju_mulPose(posres: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], quatres: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"], pos1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], quat1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"], pos2: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], quat2: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"]) -> None:
+    """
+    Multiply two poses.
+    """
+def mju_mulQuat(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"], quat1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"], quat2: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"]) -> None:
+    """
+    Multiply quaternions.
+    """
+def mju_mulQuatAxis(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"], quat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"], axis: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+    """
+    Multiply quaternion and axis.
+    """
+def mju_mulVecMatVec(vec1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"], vec2: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> float:
+    """
+    Multiply square matrix with vectors on both sides: return vec1' * mat * vec2.
+    """
+def mju_muscleBias(len: typing.SupportsFloat | typing.SupportsIndex, lengthrange: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"], acc0: typing.SupportsFloat | typing.SupportsIndex, prm: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[9, 1]"]) -> float:
+    """
+    Muscle passive force, prm = (range[2], force, scale, lmin, lmax, vmax, fpmax, fvmax).
+    """
+def mju_muscleDynamics(ctrl: typing.SupportsFloat | typing.SupportsIndex, act: typing.SupportsFloat | typing.SupportsIndex, prm: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> float:
+    """
+    Muscle activation dynamics, prm = (tau_act, tau_deact, smoothing_width).
+    """
+def mju_muscleGain(len: typing.SupportsFloat | typing.SupportsIndex, vel: typing.SupportsFloat | typing.SupportsIndex, lengthrange: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"], acc0: typing.SupportsFloat | typing.SupportsIndex, prm: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[9, 1]"]) -> float:
+    """
+    Muscle active force, prm = (range[2], force, scale, lmin, lmax, vmax, fpmax, fvmax).
+    """
+def mju_n2d(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Convert from mjtNum to double.
+    """
+def mju_n2f(res: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Convert from mjtNum to float.
+    """
+def mju_negPose(posres: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], quatres: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"], pos: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], quat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"]) -> None:
+    """
+    Conjugate pose, corresponding to the opposite spatial transformation.
+    """
+def mju_negQuat(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"], quat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"]) -> None:
+    """
+    Conjugate quaternion, corresponding to opposite rotation.
+    """
+def mju_norm(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> float:
+    """
+    Return vector length (without normalizing vector).
+    """
+def mju_norm3(vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> float:
+    """
+    Return vector length (without normalizing the vector).
+    """
+def mju_normalize(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"]) -> float:
+    """
+    Normalize vector; return length before normalization.
+    """
+def mju_normalize3(vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]) -> float:
+    """
+    Normalize vector; return length before normalization.
+    """
+def mju_normalize4(vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"]) -> float:
+    """
+    Normalize vector; return length before normalization.
+    """
+def mju_printMat(mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"]) -> None:
+    """
+    Print matrix to screen.
+    """
+def mju_printMatSparse(mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], rownnz: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]"], rowadr: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]"], colind: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]"]) -> None:
+    """
+    Print sparse matrix to screen.
+    """
+def mju_quat2Mat(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[9, 1]", "flags.writeable"], quat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"]) -> None:
+    """
+    Convert quaternion to 3D rotation matrix.
+    """
+def mju_quat2Vel(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], quat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"], dt: typing.SupportsFloat | typing.SupportsIndex) -> None:
+    """
+    Convert quaternion (corresponding to orientation difference) to 3D velocity.
+    """
+def mju_quatIntegrate(quat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"], vel: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], scale: typing.SupportsFloat | typing.SupportsIndex) -> None:
+    """
+    Integrate quaternion given 3D angular velocity.
+    """
+def mju_quatZ2Vec(quat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+    """
+    Construct quaternion performing rotation from z-axis to given vector.
+    """
+def mju_rayGeom(pos: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[9, 1]"], size: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], pnt: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], geomtype: typing.SupportsInt | typing.SupportsIndex, normal: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"] | None = None) -> float:
+    """
+    Intersect ray with pure geom; return nearest distance or -1 if no intersection.
+    """
+def mju_raySkin(nface: typing.SupportsInt | typing.SupportsIndex, nvert: typing.SupportsInt | typing.SupportsIndex, face: typing.SupportsInt | typing.SupportsIndex, vert: typing.SupportsFloat | typing.SupportsIndex, pnt: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], vertid: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[1, 1]", "flags.writeable"]) -> float:
+    """
+    Intersect ray with skin; return nearest distance or -1 if no intersection, and also output nearest vertex id.
+    """
+def mju_rotVecQuat(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], quat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"]) -> None:
+    """
+    Rotate vector by quaternion.
+    """
+def mju_round(x: typing.SupportsFloat | typing.SupportsIndex) -> int:
+    """
+    Round x to nearest integer.
+    """
+def mju_scl(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], scl: typing.SupportsFloat | typing.SupportsIndex) -> None:
+    """
+    Set res = vec*scl.
+    """
+def mju_scl3(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], scl: typing.SupportsFloat | typing.SupportsIndex) -> None:
+    """
+    Set res = vec*scl.
+    """
+def mju_sigmoid(x: typing.SupportsFloat | typing.SupportsIndex) -> float:
+    """
+    Sigmoid function over 0<=x<=1 using quintic polynomial.
+    """
+def mju_sign(x: typing.SupportsFloat | typing.SupportsIndex) -> float:
+    """
+    Return sign of x: +1, -1 or 0.
+    """
+def mju_sparse2dense(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], rownnz: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]"], rowadr: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]"], colind: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]"]) -> None:
+    """
+    Convert matrix from sparse to dense.
+    """
+def mju_springDamper(pos0: typing.SupportsFloat | typing.SupportsIndex, vel0: typing.SupportsFloat | typing.SupportsIndex, Kp: typing.SupportsFloat | typing.SupportsIndex, Kv: typing.SupportsFloat | typing.SupportsIndex, dt: typing.SupportsFloat | typing.SupportsIndex) -> float:
+    """
+    Integrate spring-damper analytically; return pos(dt).
+    """
+def mju_sqrMatTD(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"], diag: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"] | None) -> None:
+    """
+    Set res = mat' * diag * mat if diag is not NULL, and res = mat' * mat otherwise.
+    """
+def mju_standardNormal(num2: typing.SupportsFloat | typing.SupportsIndex | None) -> float:
+    """
+    Standard normal random number generator (optional second number).
+    """
+def mju_str2Type(str: str) -> int:
+    """
+    Convert type name to type id (mjtObj).
+    """
+def mju_sub(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], vec1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], vec2: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Set res = vec1 - vec2.
+    """
+def mju_sub3(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], vec1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], vec2: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+    """
+    Set res = vec1 - vec2.
+    """
+def mju_subFrom(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]) -> None:
+    """
+    Set res = res - vec.
+    """
+def mju_subFrom3(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+    """
+    Set res = res - vec.
+    """
+def mju_subQuat(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], qa: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"], qb: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"]) -> None:
+    """
+    Subtract quaternions, express as 3D velocity: qb*quat(res) = qa.
+    """
+def mju_sum(vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"]) -> float:
+    """
+    Return sum(vec).
+    """
+def mju_sym2dense(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"], rownnz: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]"], rowadr: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]"], colind: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[m, 1]"]) -> None:
+    """
+    Convert lower-triangular symmetric CSR matrix to full dense matrix.
+    """
+def mju_symmetrize(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"]) -> None:
+    """
+    Symmetrize square matrix res = (mat + mat')/2.
+    """
+def mju_threadpool(d: mujoco._structs.MjData, nthread: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Create a thread pool with nthread worker threads.
+    """
+def mju_transformSpatial(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]"], flg_force: typing.SupportsInt | typing.SupportsIndex, newpos: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], oldpos: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], rotnew2old: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[9, 1]"]) -> None:
+    """
+    Coordinate transform of 6D motion or force vector in rotation:translation format. rotnew2old is 3-by-3, NULL means no rotation; flg_force specifies force or motion type.
+    """
+def mju_transpose(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.writeable", "flags.c_contiguous"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.c_contiguous"]) -> None:
+    """
+    Transpose matrix: res = mat'.
+    """
+def mju_trnVecPose(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], pos: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], quat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+    """
+    Transform vector by pose.
+    """
+def mju_type2Str(type: typing.SupportsInt | typing.SupportsIndex) -> str:
+    """
+    Convert type id (mjtObj) to type name.
+    """
+def mju_unit4(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"]) -> None:
+    """
+    Set res = (1,0,0,0).
+    """
+def mju_warningText(warning: typing.SupportsInt | typing.SupportsIndex, info: typing.SupportsInt | typing.SupportsIndex) -> str:
+    """
+    Construct a warning message given the warning type and info.
+    """
+def mju_writeLog(type: str, msg: str) -> None:
+    """
+    Write [datetime, type: message] to MUJOCO_LOG.TXT.
+    """
+def mju_writeNumBytes(nbytes: typing.SupportsInt | typing.SupportsIndex) -> str:
+    """
+    Return human readable number of bytes using standard letter suffix.
+    """
+def mju_zero(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]", "flags.writeable"]) -> None:
+    """
+    Set res = 0.
+    """
+def mju_zero3(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]) -> None:
+    """
+    Set res = 0.
+    """
+def mju_zero4(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"]) -> None:
+    """
+    Set res = 0.
+    """
+def mjv_addGeoms(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, opt: mujoco._structs.MjvOption, pert: mujoco._structs.MjvPerturb, catmask: typing.SupportsInt | typing.SupportsIndex, scn: mujoco._structs.MjvScene) -> None:
+    """
+    Add geoms from selected categories.
+    """
+def mjv_alignToCamera(res: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], vec: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], forward: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+    """
+    Rotate 3D vec in horizontal plane by angle between (0,1) and (forward_x,forward_y).
+    """
+def mjv_applyPerturbForce(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, pert: mujoco._structs.MjvPerturb) -> None:
+    """
+    Set perturb force,torque in d->xfrc_applied, if selected body is dynamic.
+    """
+def mjv_applyPerturbPose(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, pert: mujoco._structs.MjvPerturb, flg_paused: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Set perturb pos,quat in d->mocap when selected body is mocap, and in d->qpos otherwise. Write d->qpos only if flg_paused and subtree root for selected body has free joint.
+    """
+def mjv_cameraFrame(headpos: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], forward: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], up: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], right: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], d: mujoco._structs.MjData, cam: mujoco._structs.MjvCamera) -> None:
+    """
+    Compute camera position and forward, up, and right vectors.
+    """
+def mjv_cameraFrustum(zver: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[2, 1]", "flags.writeable"], zhor: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[2, 1]", "flags.writeable"], zclip: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[2, 1]", "flags.writeable"], m: mujoco._structs.MjModel, cam: mujoco._structs.MjvCamera) -> None:
+    """
+    Compute camera frustum: vertical, horizontal, and clip planes.
+    """
+def mjv_cameraInModel(headpos: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], forward: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], up: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], scn: mujoco._structs.MjvScene) -> None:
+    """
+    Get camera info in model space; average left and right OpenGL cameras.
+    """
+def mjv_cameraInRoom(headpos: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], forward: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], up: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], scn: mujoco._structs.MjvScene) -> None:
+    """
+    Get camera info in room space; average left and right OpenGL cameras.
+    """
+def mjv_connector(geom: mujoco._structs.MjvGeom, type: typing.SupportsInt | typing.SupportsIndex, width: typing.SupportsFloat | typing.SupportsIndex, from_: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], to: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+    """
+    Set (type, size, pos, mat) for connector-type geom between given points. Assume that mjv_initGeom was already called to set all other properties. Width of mjGEOM_LINE is denominated in pixels.
+    """
+def mjv_defaultCamera(cam: mujoco._structs.MjvCamera) -> None:
+    """
+    Set default camera.
+    """
+def mjv_defaultFigure(fig: mujoco._structs.MjvFigure) -> None:
+    """
+    Set default figure.
+    """
+def mjv_defaultFreeCamera(m: mujoco._structs.MjModel, cam: mujoco._structs.MjvCamera) -> None:
+    """
+    Set default free camera.
+    """
+def mjv_defaultOption(opt: mujoco._structs.MjvOption) -> None:
+    """
+    Set default visualization options.
+    """
+def mjv_defaultPerturb(pert: mujoco._structs.MjvPerturb) -> None:
+    """
+    Set default perturbation.
+    """
+def mjv_frustumHeight(scn: mujoco._structs.MjvScene) -> float:
+    """
+    Get frustum height at unit distance from camera; average left and right OpenGL cameras.
+    """
+def mjv_initGeom(geom: mujoco._structs.MjvGeom, type: typing.SupportsInt | typing.SupportsIndex, size: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], pos: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[9, 1]"], rgba: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+    """
+    Initialize given geom fields when not NULL, set the rest to their default values.
+    """
+def mjv_initPerturb(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, scn: mujoco._structs.MjvScene, pert: mujoco._structs.MjvPerturb) -> None:
+    """
+    Copy perturb pos,quat from selected body; set scale for perturbation.
+    """
+def mjv_makeLights(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, scn: mujoco._structs.MjvScene) -> None:
+    """
+    Make list of lights.
+    """
+def mjv_model2room(roompos: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], roomquat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"], modelpos: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], modelquat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"], scn: mujoco._structs.MjvScene) -> None:
+    """
+    Transform pose from model to room space.
+    """
+def mjv_moveCamera(m: mujoco._structs.MjModel, action: typing.SupportsInt | typing.SupportsIndex, reldx: typing.SupportsFloat | typing.SupportsIndex, reldy: typing.SupportsFloat | typing.SupportsIndex, cam: mujoco._structs.MjvCamera) -> None:
+    """
+    Move camera with mouse; action is mjtMouse.
+    """
+def mjv_moveModel(m: mujoco._structs.MjModel, action: typing.SupportsInt | typing.SupportsIndex, reldx: typing.SupportsFloat | typing.SupportsIndex, reldy: typing.SupportsFloat | typing.SupportsIndex, roomup: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], scn: mujoco._structs.MjvScene) -> None:
+    """
+    Move model with mouse; action is mjtMouse.
+    """
+def mjv_movePerturb(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, action: typing.SupportsInt | typing.SupportsIndex, reldx: typing.SupportsFloat | typing.SupportsIndex, reldy: typing.SupportsFloat | typing.SupportsIndex, scn: mujoco._structs.MjvScene, pert: mujoco._structs.MjvPerturb) -> None:
+    """
+    Move perturb object with mouse; action is mjtMouse.
+    """
+def mjv_room2model(modelpos: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], modelquat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"], roompos: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"], roomquat: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"], scn: mujoco._structs.MjvScene) -> None:
+    """
+    Transform pose from room to model space.
+    """
+def mjv_select(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, vopt: mujoco._structs.MjvOption, aspectratio: typing.SupportsFloat | typing.SupportsIndex, relx: typing.SupportsFloat | typing.SupportsIndex, rely: typing.SupportsFloat | typing.SupportsIndex, scn: mujoco._structs.MjvScene, selpnt: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"], geomid: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[1, 1]", "flags.writeable"], flexid: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[1, 1]", "flags.writeable"], skinid: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[1, 1]", "flags.writeable"]) -> int:
+    """
+    Select geom, flex or skin with mouse; return bodyid; -1: none selected.
+    """
+def mjv_updateCamera(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, cam: mujoco._structs.MjvCamera, scn: mujoco._structs.MjvScene) -> None:
+    """
+    Update camera.
+    """
+def mjv_updateScene(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, opt: mujoco._structs.MjvOption, pert: mujoco._structs.MjvPerturb | None, cam: mujoco._structs.MjvCamera, catmask: typing.SupportsInt | typing.SupportsIndex, scn: mujoco._structs.MjvScene) -> None:
+    """
+    Update entire scene given model state.
+    """
+def mjv_updateSkin(m: mujoco._structs.MjModel, d: mujoco._structs.MjData, scn: mujoco._structs.MjvScene) -> None:
+    """
+    Update skins.
+    """
diff --git a/typings/mujoco/_render.pyi b/typings/mujoco/_render.pyi
new file mode 100644
index 0000000..02ae498
--- /dev/null
+++ b/typings/mujoco/_render.pyi
@@ -0,0 +1,486 @@
+from __future__ import annotations
+import mujoco._structs
+import numpy
+import numpy.typing
+import typing
+__all__: list[str] = ['MjrContext', 'MjrRendererInfo', 'mjr_addAux', 'mjr_blitAux', 'mjr_blitBuffer', 'mjr_changeFont', 'mjr_defaultRendererInfo', 'mjr_drawPixels', 'mjr_figure', 'mjr_findRect', 'mjr_finish', 'mjr_getError', 'mjr_getRendererInfo', 'mjr_label', 'mjr_maxViewport', 'mjr_overlay', 'mjr_readPixels', 'mjr_rectangle', 'mjr_render', 'mjr_resizeOffscreen', 'mjr_restoreBuffer', 'mjr_setAux', 'mjr_setBuffer', 'mjr_text', 'mjr_uploadHField', 'mjr_uploadMesh', 'mjr_uploadTexture']
+class MjrContext:
+    @typing.overload
+    def __init__(self) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: mujoco._structs.MjModel, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def free(self) -> None:
+        """
+        Frees resources in current active OpenGL context, sets struct to default.
+        """
+    @property
+    def auxColor(self) -> numpy.typing.NDArray[numpy.uint32]:
+        ...
+    @auxColor.setter
+    def auxColor(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def auxColor_r(self) -> numpy.typing.NDArray[numpy.uint32]:
+        ...
+    @auxColor_r.setter
+    def auxColor_r(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def auxFBO(self) -> numpy.typing.NDArray[numpy.uint32]:
+        ...
+    @auxFBO.setter
+    def auxFBO(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def auxFBO_r(self) -> numpy.typing.NDArray[numpy.uint32]:
+        ...
+    @auxFBO_r.setter
+    def auxFBO_r(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def auxHeight(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @auxHeight.setter
+    def auxHeight(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def auxSamples(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @auxSamples.setter
+    def auxSamples(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def auxWidth(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @auxWidth.setter
+    def auxWidth(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def baseBuiltin(self) -> int:
+        ...
+    @baseBuiltin.setter
+    def baseBuiltin(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def baseFontBig(self) -> int:
+        ...
+    @baseFontBig.setter
+    def baseFontBig(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def baseFontNormal(self) -> int:
+        ...
+    @baseFontNormal.setter
+    def baseFontNormal(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def baseFontShadow(self) -> int:
+        ...
+    @baseFontShadow.setter
+    def baseFontShadow(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def baseHField(self) -> int:
+        ...
+    @baseHField.setter
+    def baseHField(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def baseMesh(self) -> int:
+        ...
+    @baseMesh.setter
+    def baseMesh(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def basePlane(self) -> int:
+        ...
+    @basePlane.setter
+    def basePlane(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def charHeight(self) -> int:
+        ...
+    @charHeight.setter
+    def charHeight(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def charHeightBig(self) -> int:
+        ...
+    @charHeightBig.setter
+    def charHeightBig(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def charWidth(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @charWidth.setter
+    def charWidth(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def charWidthBig(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @charWidthBig.setter
+    def charWidthBig(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def currentBuffer(self) -> int:
+        ...
+    @currentBuffer.setter
+    def currentBuffer(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def fogEnd(self) -> float:
+        ...
+    @fogEnd.setter
+    def fogEnd(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def fogRGBA(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @fogRGBA.setter
+    def fogRGBA(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def fogStart(self) -> float:
+        ...
+    @fogStart.setter
+    def fogStart(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def fontScale(self) -> int:
+        ...
+    @fontScale.setter
+    def fontScale(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def glInitialized(self) -> int:
+        ...
+    @glInitialized.setter
+    def glInitialized(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def lineWidth(self) -> float:
+        ...
+    @lineWidth.setter
+    def lineWidth(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def mat_texid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mat_texid.setter
+    def mat_texid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mat_texrepeat(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @mat_texrepeat.setter
+    def mat_texrepeat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mat_texuniform(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mat_texuniform.setter
+    def mat_texuniform(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def nskin(self) -> int:
+        ...
+    @property
+    def ntexture(self) -> int:
+        ...
+    @ntexture.setter
+    def ntexture(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def offColor(self) -> int:
+        ...
+    @offColor.setter
+    def offColor(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def offColor_r(self) -> int:
+        ...
+    @offColor_r.setter
+    def offColor_r(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def offDepthStencil(self) -> int:
+        ...
+    @offDepthStencil.setter
+    def offDepthStencil(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def offDepthStencil_r(self) -> int:
+        ...
+    @offDepthStencil_r.setter
+    def offDepthStencil_r(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def offFBO(self) -> int:
+        ...
+    @offFBO.setter
+    def offFBO(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def offFBO_r(self) -> int:
+        ...
+    @offFBO_r.setter
+    def offFBO_r(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def offHeight(self) -> int:
+        ...
+    @offHeight.setter
+    def offHeight(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def offSamples(self) -> int:
+        ...
+    @offSamples.setter
+    def offSamples(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def offWidth(self) -> int:
+        ...
+    @offWidth.setter
+    def offWidth(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def rangeBuiltin(self) -> int:
+        ...
+    @rangeBuiltin.setter
+    def rangeBuiltin(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def rangeFont(self) -> int:
+        ...
+    @rangeFont.setter
+    def rangeFont(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def rangeHField(self) -> int:
+        ...
+    @rangeHField.setter
+    def rangeHField(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def rangeMesh(self) -> int:
+        ...
+    @rangeMesh.setter
+    def rangeMesh(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def rangePlane(self) -> int:
+        ...
+    @rangePlane.setter
+    def rangePlane(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def readDepthMap(self) -> int:
+        ...
+    @readDepthMap.setter
+    def readDepthMap(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def readPixelFormat(self) -> int:
+        ...
+    @readPixelFormat.setter
+    def readPixelFormat(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def shadowClip(self) -> float:
+        ...
+    @shadowClip.setter
+    def shadowClip(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def shadowFBO(self) -> int:
+        ...
+    @shadowFBO.setter
+    def shadowFBO(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def shadowScale(self) -> float:
+        ...
+    @shadowScale.setter
+    def shadowScale(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def shadowSize(self) -> int:
+        ...
+    @shadowSize.setter
+    def shadowSize(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def shadowTex(self) -> int:
+        ...
+    @shadowTex.setter
+    def shadowTex(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def skinfaceVBO(self) -> tuple:
+        ...
+    @property
+    def skinnormalVBO(self) -> tuple:
+        ...
+    @property
+    def skintexcoordVBO(self) -> tuple:
+        ...
+    @property
+    def skinvertVBO(self) -> tuple:
+        ...
+    @property
+    def texture(self) -> numpy.typing.NDArray[numpy.uint32]:
+        ...
+    @texture.setter
+    def texture(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def textureType(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @textureType.setter
+    def textureType(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def windowAvailable(self) -> int:
+        ...
+    @windowAvailable.setter
+    def windowAvailable(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def windowDoublebuffer(self) -> int:
+        ...
+    @windowDoublebuffer.setter
+    def windowDoublebuffer(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def windowSamples(self) -> int:
+        ...
+    @windowSamples.setter
+    def windowSamples(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def windowStereo(self) -> int:
+        ...
+    @windowStereo.setter
+    def windowStereo(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+class MjrRendererInfo:
+    __hash__: typing.ClassVar[None] = None
+    def __copy__(self) -> MjrRendererInfo:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjrRendererInfo:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def backend(self) -> str:
+        ...
+    @property
+    def renderer(self) -> str:
+        ...
+def mjr_addAux(index: typing.SupportsInt | typing.SupportsIndex, width: typing.SupportsInt | typing.SupportsIndex, height: typing.SupportsInt | typing.SupportsIndex, samples: typing.SupportsInt | typing.SupportsIndex, con: MjrContext) -> None:
+    """
+    Add Aux buffer with given index to context; free previous Aux buffer.
+    """
+def mjr_blitAux(index: typing.SupportsInt | typing.SupportsIndex, src: mujoco._structs.MjrRect, left: typing.SupportsInt | typing.SupportsIndex, bottom: typing.SupportsInt | typing.SupportsIndex, con: MjrContext) -> None:
+    """
+    Blit from Aux buffer to con->currentBuffer.
+    """
+def mjr_blitBuffer(src: mujoco._structs.MjrRect, dst: mujoco._structs.MjrRect, flg_color: typing.SupportsInt | typing.SupportsIndex, flg_depth: typing.SupportsInt | typing.SupportsIndex, con: MjrContext) -> None:
+    """
+    Blit from src viewpoint in current framebuffer to dst viewport in other framebuffer. If src, dst have different size and flg_depth==0, color is interpolated with GL_LINEAR.
+    """
+def mjr_changeFont(fontscale: typing.SupportsInt | typing.SupportsIndex, con: MjrContext) -> None:
+    """
+    Change font of existing context.
+    """
+def mjr_defaultRendererInfo(info: MjrRendererInfo) -> None:
+    """
+    Set default mjrRendererInfo.
+    """
+def mjr_drawPixels(rgb: typing.Annotated[numpy.typing.NDArray[numpy.uint8], "[m, 1]"] | None, depth: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, 1]"] | None, viewport: mujoco._structs.MjrRect, con: MjrContext) -> None:
+    """
+    Draw pixels from client buffer to current OpenGL framebuffer. Viewport is in OpenGL framebuffer; client buffer starts at (0,0).
+    """
+def mjr_figure(viewport: mujoco._structs.MjrRect, fig: mujoco._structs.MjvFigure, con: MjrContext) -> None:
+    """
+    Draw 2D figure.
+    """
+def mjr_findRect(x: typing.SupportsInt | typing.SupportsIndex, y: typing.SupportsInt | typing.SupportsIndex, nrect: typing.SupportsInt | typing.SupportsIndex, rect: mujoco._structs.MjrRect) -> int:
+    """
+    Find first rectangle containing mouse, -1: not found.
+    """
+def mjr_finish() -> None:
+    """
+    Call glFinish.
+    """
+def mjr_getError() -> int:
+    """
+    Call glGetError and return result.
+    """
+def mjr_getRendererInfo(info: MjrRendererInfo) -> None:
+    """
+    Get active renderer information.
+    """
+def mjr_label(viewport: mujoco._structs.MjrRect, font: typing.SupportsInt | typing.SupportsIndex, txt: str, r: typing.SupportsFloat | typing.SupportsIndex, g: typing.SupportsFloat | typing.SupportsIndex, b: typing.SupportsFloat | typing.SupportsIndex, a: typing.SupportsFloat | typing.SupportsIndex, rt: typing.SupportsFloat | typing.SupportsIndex, gt: typing.SupportsFloat | typing.SupportsIndex, bt: typing.SupportsFloat | typing.SupportsIndex, con: MjrContext) -> None:
+    """
+    Draw rectangle with centered text.
+    """
+def mjr_maxViewport(con: MjrContext) -> mujoco._structs.MjrRect:
+    """
+    Get maximum viewport for active buffer.
+    """
+def mjr_overlay(font: typing.SupportsInt | typing.SupportsIndex, gridpos: typing.SupportsInt | typing.SupportsIndex, viewport: mujoco._structs.MjrRect, overlay: str, overlay2: str, con: MjrContext) -> None:
+    """
+    Draw text overlay; font is mjtFont; gridpos is mjtGridPos.
+    """
+def mjr_readPixels(rgb: typing.Annotated[numpy.typing.ArrayLike, numpy.uint8] | None, depth: typing.Annotated[numpy.typing.ArrayLike, numpy.float32] | None, viewport: mujoco._structs.MjrRect, con: MjrContext) -> None:
+    """
+    Read pixels from current OpenGL framebuffer to client buffer. Viewport is in OpenGL framebuffer; client buffer starts at (0,0).
+    """
+def mjr_rectangle(viewport: mujoco._structs.MjrRect, r: typing.SupportsFloat | typing.SupportsIndex, g: typing.SupportsFloat | typing.SupportsIndex, b: typing.SupportsFloat | typing.SupportsIndex, a: typing.SupportsFloat | typing.SupportsIndex) -> None:
+    """
+    Draw rectangle.
+    """
+def mjr_render(viewport: mujoco._structs.MjrRect, scn: mujoco._structs.MjvScene, con: MjrContext) -> None:
+    """
+    Render 3D scene.
+    """
+def mjr_resizeOffscreen(width: typing.SupportsInt | typing.SupportsIndex, height: typing.SupportsInt | typing.SupportsIndex, con: MjrContext) -> None:
+    """
+    Resize offscreen buffers.
+    """
+def mjr_restoreBuffer(con: MjrContext) -> None:
+    """
+    Make con->currentBuffer current again.
+    """
+def mjr_setAux(index: typing.SupportsInt | typing.SupportsIndex, con: MjrContext) -> None:
+    """
+    Set Aux buffer for custom OpenGL rendering (call restoreBuffer when done).
+    """
+def mjr_setBuffer(framebuffer: typing.SupportsInt | typing.SupportsIndex, con: MjrContext) -> None:
+    """
+    Set OpenGL framebuffer for rendering: mjFB_WINDOW or mjFB_OFFSCREEN. If only one buffer is available, set that buffer and ignore framebuffer argument.
+    """
+def mjr_text(font: typing.SupportsInt | typing.SupportsIndex, txt: str, con: MjrContext, x: typing.SupportsFloat | typing.SupportsIndex, y: typing.SupportsFloat | typing.SupportsIndex, r: typing.SupportsFloat | typing.SupportsIndex, g: typing.SupportsFloat | typing.SupportsIndex, b: typing.SupportsFloat | typing.SupportsIndex) -> None:
+    """
+    Draw text at (x,y) in relative coordinates; font is mjtFont.
+    """
+def mjr_uploadHField(m: mujoco._structs.MjModel, con: MjrContext, hfieldid: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Upload height field to GPU, overwriting previous upload if any.
+    """
+def mjr_uploadMesh(m: mujoco._structs.MjModel, con: MjrContext, meshid: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Upload mesh to GPU, overwriting previous upload if any.
+    """
+def mjr_uploadTexture(m: mujoco._structs.MjModel, con: MjrContext, texid: typing.SupportsInt | typing.SupportsIndex) -> None:
+    """
+    Upload texture to GPU, overwriting previous upload if any.
+    """
diff --git a/typings/mujoco/_specs.pyi b/typings/mujoco/_specs.pyi
new file mode 100644
index 0000000..fa85551
--- /dev/null
+++ b/typings/mujoco/_specs.pyi
@@ -0,0 +1,3924 @@
+from __future__ import annotations
+import collections.abc
+import mujoco._enums
+import mujoco._structs
+import numpy
+import numpy.typing
+import typing
+__all__: list[str] = ['MjByteVec', 'MjCharVec', 'MjDoubleVec', 'MjFloatVec', 'MjIntVec', 'MjOption', 'MjSpec', 'MjStatistic', 'MjStringVec', 'MjVfs', 'MjVisual', 'MjVisualHeadlight', 'MjVisualRgba', 'MjsActuator', 'MjsAuthored', 'MjsBody', 'MjsCamera', 'MjsCompiler', 'MjsDefault', 'MjsElement', 'MjsEquality', 'MjsExclude', 'MjsFlex', 'MjsFrame', 'MjsGeom', 'MjsHField', 'MjsJoint', 'MjsKey', 'MjsLight', 'MjsMaterial', 'MjsMesh', 'MjsNumeric', 'MjsOrientation', 'MjsPair', 'MjsPlugin', 'MjsSensor', 'MjsSite', 'MjsSkin', 'MjsTendon', 'MjsTendonPath', 'MjsText', 'MjsTexture', 'MjsTuple', 'MjsWrap']
+class MjByteVec:
+    def __getitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    def __init__(self, arg0: ..., arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __iter__(self) -> collections.abc.Iterator[...]:
+        ...
+    def __len__(self) -> int:
+        ...
+    def __setitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex, arg1: ...) -> None:
+        ...
+class MjCharVec:
+    def __getitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> str:
+        ...
+    def __init__(self, arg0: str, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __iter__(self) -> collections.abc.Iterator[str]:
+        ...
+    def __len__(self) -> int:
+        ...
+    def __setitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex, arg1: str) -> None:
+        ...
+class MjDoubleVec:
+    def __getitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> float:
+        ...
+    def __init__(self, arg0: typing.SupportsFloat | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __iter__(self) -> collections.abc.Iterator[float]:
+        ...
+    def __len__(self) -> int:
+        ...
+    def __setitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+class MjFloatVec:
+    def __getitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> float:
+        ...
+    def __init__(self, arg0: typing.SupportsFloat | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __iter__(self) -> collections.abc.Iterator[float]:
+        ...
+    def __len__(self) -> int:
+        ...
+    def __setitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+class MjIntVec:
+    def __getitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> int:
+        ...
+    def __init__(self, arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __iter__(self) -> collections.abc.Iterator[int]:
+        ...
+    def __len__(self) -> int:
+        ...
+    def __setitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjOption:
+    @property
+    def ccd_iterations(self) -> int:
+        ...
+    @ccd_iterations.setter
+    def ccd_iterations(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def ccd_tolerance(self) -> float:
+        ...
+    @ccd_tolerance.setter
+    def ccd_tolerance(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def cone(self) -> int:
+        ...
+    @cone.setter
+    def cone(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def density(self) -> float:
+        ...
+    @density.setter
+    def density(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def disableactuator(self) -> int:
+        ...
+    @disableactuator.setter
+    def disableactuator(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def disableflags(self) -> int:
+        ...
+    @disableflags.setter
+    def disableflags(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def enableflags(self) -> int:
+        ...
+    @enableflags.setter
+    def enableflags(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def gravity(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @gravity.setter
+    def gravity(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def impratio(self) -> float:
+        ...
+    @impratio.setter
+    def impratio(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def integrator(self) -> int:
+        ...
+    @integrator.setter
+    def integrator(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def iterations(self) -> int:
+        ...
+    @iterations.setter
+    def iterations(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def jacobian(self) -> int:
+        ...
+    @jacobian.setter
+    def jacobian(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def ls_iterations(self) -> int:
+        ...
+    @ls_iterations.setter
+    def ls_iterations(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def ls_tolerance(self) -> float:
+        ...
+    @ls_tolerance.setter
+    def ls_tolerance(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def magnetic(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @magnetic.setter
+    def magnetic(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def noslip_iterations(self) -> int:
+        ...
+    @noslip_iterations.setter
+    def noslip_iterations(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def noslip_tolerance(self) -> float:
+        ...
+    @noslip_tolerance.setter
+    def noslip_tolerance(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def o_friction(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]", "flags.writeable"]:
+        ...
+    @o_friction.setter
+    def o_friction(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]"]) -> None:
+        ...
+    @property
+    def o_margin(self) -> float:
+        ...
+    @o_margin.setter
+    def o_margin(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def o_solimp(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]", "flags.writeable"]:
+        ...
+    @o_solimp.setter
+    def o_solimp(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]"]) -> None:
+        ...
+    @property
+    def o_solref(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @o_solref.setter
+    def o_solref(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def sdf_initpoints(self) -> int:
+        ...
+    @sdf_initpoints.setter
+    def sdf_initpoints(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def sdf_iterations(self) -> int:
+        ...
+    @sdf_iterations.setter
+    def sdf_iterations(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def sleep_tolerance(self) -> float:
+        ...
+    @sleep_tolerance.setter
+    def sleep_tolerance(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def solver(self) -> int:
+        ...
+    @solver.setter
+    def solver(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def timestep(self) -> float:
+        ...
+    @timestep.setter
+    def timestep(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def tolerance(self) -> float:
+        ...
+    @tolerance.setter
+    def tolerance(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def viscosity(self) -> float:
+        ...
+    @viscosity.setter
+    def viscosity(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def wind(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @wind.setter
+    def wind(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+class MjSpec:
+    assets: dict
+    authored: MjsAuthored
+    comment: str
+    compiler: MjsCompiler
+    hasImplicitPluginElem: bool
+    meshdir: str
+    modelfiledir: str
+    modelname: str
+    option: MjOption
+    override_assets: bool
+    stat: MjStatistic
+    strippath: bool
+    texturedir: str
+    visual: MjVisual
+    @staticmethod
+    def from_file(filename: str, include: collections.abc.Mapping[str, bytes] | None = None, assets: dict | None = None, vfs: MjVfs = None) -> MjSpec:
+        """
+            Creates a spec from an XML file.
+        
+            Parameters
+            ----------
+            filename : str
+                Path to the XML file.
+            include : dict, optional
+                A dictionary of xml files included by the model. The keys are file names
+                and the values are file contents.
+            assets : dict, optional
+                A dictionary of assets to be used by the spec. The keys are asset names
+                and the values are asset contents.
+            vfs : MjVfs, optional
+                A VFS to use for resolving includes and assets. Cannot be used with
+                include or assets.
+        """
+    @staticmethod
+    def from_string(xml: str, include: collections.abc.Mapping[str, bytes] | None = None, assets: dict | None = None, vfs: MjVfs = None) -> MjSpec:
+        """
+            Creates a spec from an XML string.
+        
+            Parameters
+            ----------
+            xml : str
+                XML string.
+            include : dict, optional
+                A dictionary of xml files included by the model. The keys are file names
+                and the values are file contents.
+            assets : dict, optional
+                A dictionary of assets to be used by the spec. The keys are asset names
+                and the values are asset contents.
+            vfs : MjVfs, optional
+                A VFS to use for resolving includes and assets. Cannot be used with
+                include or assets.
+        """
+    @staticmethod
+    def from_zip(file: typing.Union[str, typing.IO[bytes]]) -> MjSpec:
+        """
+        Reads a zip file and returns an MjSpec.
+        
+        Args:
+          file: The path to the file to read from or the file object to read from.
+        Returns:
+          An MjSpec object.
+        """
+    @staticmethod
+    def resolve_orientation(degree: bool, sequence: MjCharVec = None, orientation: MjsOrientation) -> typing.Annotated[list[float], "FixedSize(4)"]:
+        ...
+    @staticmethod
+    def to_zip(spec: MjSpec, file: typing.Union[str, typing.IO[bytes]]) -> None:
+        """
+        Converts an MjSpec to a zip file.
+        
+        Args:
+          spec: The mjSpec to save to a file.
+          file: The path to the file to save to or the file object to write to.
+        """
+    def __init__(self) -> None:
+        ...
+    def activate_plugin(self, name: str) -> None:
+        ...
+    def actuator(self, arg0: str) -> MjsActuator:
+        ...
+    def add_actuator(self, default: MjsDefault = None, name: str | None = None, gaintype: typing.SupportsInt | typing.SupportsIndex | None = None, gainprm: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, biastype: typing.SupportsInt | typing.SupportsIndex | None = None, biasprm: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, dyntype: typing.SupportsInt | typing.SupportsIndex | None = None, dynprm: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, actdim: typing.SupportsInt | typing.SupportsIndex | None = None, ctrlspec: typing.SupportsInt | typing.SupportsIndex | None = None, actearly: typing.SupportsInt | typing.SupportsIndex | None = None, trntype: typing.SupportsInt | typing.SupportsIndex | None = None, gear: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, target: str | None = None, refsite: str | None = None, slidersite: str | None = None, cranklength: typing.SupportsFloat | typing.SupportsIndex | None = None, lengthrange: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, inheritrange: typing.SupportsFloat | typing.SupportsIndex | None = None, damping: typing.Any | None = None, armature: typing.SupportsFloat | typing.SupportsIndex | None = None, ctrllimited: typing.SupportsInt | typing.SupportsIndex | None = None, ctrlrange: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, forcelimited: typing.SupportsInt | typing.SupportsIndex | None = None, forcerange: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, actlimited: typing.SupportsInt | typing.SupportsIndex | None = None, actrange: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, group: typing.SupportsInt | typing.SupportsIndex | None = None, nsample: typing.SupportsInt | typing.SupportsIndex | None = None, interp: typing.SupportsInt | typing.SupportsIndex | None = None, delay: typing.SupportsFloat | typing.SupportsIndex | None = None, userdata: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, plugin: mujoco._specs.MjsPlugin | None = None, info: str | None = None) -> MjsActuator:
+        """
+              Add actuator to spec.
+        
+              Args:
+                name: str
+                gaintype: int
+                gainprm: list[float]
+                biastype: int
+                biasprm: list[float]
+                dyntype: int
+                dynprm: list[float]
+                actdim: int
+                ctrlspec: int
+                actearly: int
+                trntype: int
+                gear: list[float]
+                target: str
+                refsite: str
+                slidersite: str
+                cranklength: float
+                lengthrange: list[float]
+                inheritrange: float
+                damping: Optional[list[float]]
+                armature: float
+                ctrllimited: int
+                ctrlrange: list[float]
+                forcelimited: int
+                forcerange: list[float]
+                actlimited: int
+                actrange: list[float]
+                group: int
+                nsample: int
+                interp: int
+                delay: float
+                userdata: list[float]
+                plugin: MjsPlugin
+                info: str
+        """
+    def add_default(self, arg0: str, arg1: MjsDefault) -> MjsDefault:
+        ...
+    def add_equality(self, default: MjsDefault = None, name: str | None = None, type: typing.SupportsInt | typing.SupportsIndex | None = None, data: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, active: typing.SupportsInt | typing.SupportsIndex | None = None, name1: str | None = None, name2: str | None = None, objtype: typing.SupportsInt | typing.SupportsIndex | None = None, solref: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, solimp: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsEquality:
+        """
+              Add equality to spec.
+        
+              Args:
+                name: str
+                type: int
+                data: list[float]
+                active: int
+                name1: str
+                name2: str
+                objtype: int
+                solref: list[float]
+                solimp: list[float]
+                info: str
+        """
+    def add_exclude(self, name: str | None = None, bodyname1: str | None = None, bodyname2: str | None = None, info: str | None = None) -> MjsExclude:
+        """
+              Add exclude to spec.
+        
+              Args:
+                name: str
+                bodyname1: str
+                bodyname2: str
+                info: str
+        """
+    def add_flex(self, name: str | None = None, contype: typing.SupportsInt | typing.SupportsIndex | None = None, conaffinity: typing.SupportsInt | typing.SupportsIndex | None = None, condim: typing.SupportsInt | typing.SupportsIndex | None = None, priority: typing.SupportsInt | typing.SupportsIndex | None = None, friction: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, solmix: typing.SupportsFloat | typing.SupportsIndex | None = None, solref: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, solimp: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, margin: typing.SupportsFloat | typing.SupportsIndex | None = None, gap: typing.SupportsFloat | typing.SupportsIndex | None = None, dim: typing.SupportsInt | typing.SupportsIndex | None = None, radius: typing.SupportsFloat | typing.SupportsIndex | None = None, size: typing.Any | None = None, internal: typing.SupportsInt | typing.SupportsIndex | None = None, flatskin: typing.SupportsInt | typing.SupportsIndex | None = None, selfcollide: typing.SupportsInt | typing.SupportsIndex | None = None, passive: typing.SupportsInt | typing.SupportsIndex | None = None, activelayers: typing.SupportsInt | typing.SupportsIndex | None = None, group: typing.SupportsInt | typing.SupportsIndex | None = None, edgestiffness: typing.SupportsFloat | typing.SupportsIndex | None = None, edgedamping: typing.SupportsFloat | typing.SupportsIndex | None = None, rgba: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, material: str | None = None, young: typing.SupportsFloat | typing.SupportsIndex | None = None, poisson: typing.SupportsFloat | typing.SupportsIndex | None = None, damping: typing.SupportsFloat | typing.SupportsIndex | None = None, thickness: typing.SupportsFloat | typing.SupportsIndex | None = None, elastic2d: typing.SupportsInt | typing.SupportsIndex | None = None, cellcount: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, order: typing.SupportsInt | typing.SupportsIndex | None = None, nodebody: collections.abc.Sequence[str] | None = None, vertbody: collections.abc.Sequence[str] | None = None, node: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, vert: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, elem: collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex] | None = None, texcoord: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, elemtexcoord: collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsFlex:
+        """
+              Add flex to spec.
+        
+              Args:
+                name: str
+                contype: int
+                conaffinity: int
+                condim: int
+                priority: int
+                friction: list[float]
+                solmix: float
+                solref: list[float]
+                solimp: list[float]
+                margin: float
+                gap: float
+                dim: int
+                radius: float
+                size: Optional[list[float]]
+                internal: int
+                flatskin: int
+                selfcollide: int
+                passive: int
+                activelayers: int
+                group: int
+                edgestiffness: float
+                edgedamping: float
+                rgba: list[float]
+                material: str
+                young: float
+                poisson: float
+                damping: float
+                thickness: float
+                elastic2d: int
+                cellcount: list[float]
+                order: int
+                nodebody: list[str]
+                vertbody: list[str]
+                node: list[float]
+                vert: list[float]
+                elem: list[int]
+                texcoord: list[float]
+                elemtexcoord: list[int]
+                info: str
+        """
+    def add_hfield(self, name: str | None = None, content_type: str | None = None, file: str | None = None, size: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, nrow: typing.SupportsInt | typing.SupportsIndex | None = None, ncol: typing.SupportsInt | typing.SupportsIndex | None = None, userdata: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsHField:
+        """
+              Add hfield to spec.
+        
+              Args:
+                name: str
+                content_type: str
+                file: str
+                size: list[float]
+                nrow: int
+                ncol: int
+                userdata: list[float]
+                info: str
+        """
+    def add_key(self, name: str | None = None, time: typing.SupportsFloat | typing.SupportsIndex | None = None, qpos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, qvel: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, act: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, mpos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, mquat: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, ctrl: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsKey:
+        """
+              Add key to spec.
+        
+              Args:
+                name: str
+                time: float
+                qpos: list[float]
+                qvel: list[float]
+                act: list[float]
+                mpos: list[float]
+                mquat: list[float]
+                ctrl: list[float]
+                info: str
+        """
+    def add_material(self, default: MjsDefault = None, name: str | None = None, textures: collections.abc.Sequence[str] | None = None, texuniform: typing.SupportsInt | typing.SupportsIndex | None = None, texrepeat: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, emission: typing.SupportsFloat | typing.SupportsIndex | None = None, specular: typing.SupportsFloat | typing.SupportsIndex | None = None, shininess: typing.SupportsFloat | typing.SupportsIndex | None = None, reflectance: typing.SupportsFloat | typing.SupportsIndex | None = None, metallic: typing.SupportsFloat | typing.SupportsIndex | None = None, roughness: typing.SupportsFloat | typing.SupportsIndex | None = None, rgba: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsMaterial:
+        """
+              Add material to spec.
+        
+              Args:
+                name: str
+                textures: list[str]
+                texuniform: int
+                texrepeat: list[float]
+                emission: float
+                specular: float
+                shininess: float
+                reflectance: float
+                metallic: float
+                roughness: float
+                rgba: list[float]
+                info: str
+        """
+    def add_mesh(self, default: MjsDefault = None, name: str | None = None, content_type: str | None = None, file: str | None = None, refpos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, refquat: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, scale: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, inertia: typing.SupportsInt | typing.SupportsIndex | None = None, smoothnormal: typing.SupportsInt | typing.SupportsIndex | None = None, needsdf: typing.SupportsInt | typing.SupportsIndex | None = None, maxhullvert: typing.SupportsInt | typing.SupportsIndex | None = None, uservert: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, usernormal: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, usertexcoord: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, userface: collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex] | None = None, userfacenormal: collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex] | None = None, userfacetexcoord: collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex] | None = None, plugin: mujoco._specs.MjsPlugin | None = None, material: str | None = None, octree_maxdepth: typing.SupportsInt | typing.SupportsIndex | None = None, info: str | None = None) -> MjsMesh:
+        """
+              Add mesh to spec.
+        
+              Args:
+                name: str
+                content_type: str
+                file: str
+                refpos: list[float]
+                refquat: list[float]
+                scale: list[float]
+                inertia: int
+                smoothnormal: int
+                needsdf: int
+                maxhullvert: int
+                uservert: list[float]
+                usernormal: list[float]
+                usertexcoord: list[float]
+                userface: list[int]
+                userfacenormal: list[int]
+                userfacetexcoord: list[int]
+                plugin: MjsPlugin
+                material: str
+                octree_maxdepth: int
+                info: str
+        """
+    def add_numeric(self, name: str | None = None, data: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, size: typing.SupportsInt | typing.SupportsIndex | None = None, info: str | None = None) -> MjsNumeric:
+        """
+              Add numeric to spec.
+        
+              Args:
+                name: str
+                data: list[float]
+                size: int
+                info: str
+        """
+    def add_pair(self, default: MjsDefault = None, name: str | None = None, geomname1: str | None = None, geomname2: str | None = None, condim: typing.SupportsInt | typing.SupportsIndex | None = None, solref: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, solreffriction: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, solimp: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, margin: typing.SupportsFloat | typing.SupportsIndex | None = None, gap: typing.SupportsFloat | typing.SupportsIndex | None = None, adhesion: typing.SupportsFloat | typing.SupportsIndex | None = None, friction: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsPair:
+        """
+              Add pair to spec.
+        
+              Args:
+                name: str
+                geomname1: str
+                geomname2: str
+                condim: int
+                solref: list[float]
+                solreffriction: list[float]
+                solimp: list[float]
+                margin: float
+                gap: float
+                adhesion: float
+                friction: list[float]
+                info: str
+        """
+    def add_plugin(self, name: str | None = None, plugin_name: str | None = None, active: typing.SupportsInt | typing.SupportsIndex | None = None, info: str | None = None) -> MjsPlugin:
+        """
+              Add plugin to spec.
+        
+              Args:
+                name: str
+                plugin_name: str
+                active: int
+                info: str
+        """
+    def add_sensor(self, name: str | None = None, type: typing.SupportsInt | typing.SupportsIndex | None = None, objtype: typing.SupportsInt | typing.SupportsIndex | None = None, objname: str | None = None, reftype: typing.SupportsInt | typing.SupportsIndex | None = None, refname: str | None = None, intprm: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, datatype: typing.SupportsInt | typing.SupportsIndex | None = None, needstage: typing.SupportsInt | typing.SupportsIndex | None = None, dim: typing.SupportsInt | typing.SupportsIndex | None = None, cutoff: typing.SupportsFloat | typing.SupportsIndex | None = None, noise: typing.SupportsFloat | typing.SupportsIndex | None = None, nsample: typing.SupportsInt | typing.SupportsIndex | None = None, interp: typing.SupportsInt | typing.SupportsIndex | None = None, delay: typing.SupportsFloat | typing.SupportsIndex | None = None, interval: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, userdata: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, plugin: mujoco._specs.MjsPlugin | None = None, info: str | None = None) -> MjsSensor:
+        """
+              Add sensor to spec.
+        
+              Args:
+                name: str
+                type: int
+                objtype: int
+                objname: str
+                reftype: int
+                refname: str
+                intprm: list[float]
+                datatype: int
+                needstage: int
+                dim: int
+                cutoff: float
+                noise: float
+                nsample: int
+                interp: int
+                delay: float
+                interval: list[float]
+                userdata: list[float]
+                plugin: MjsPlugin
+                info: str
+        """
+    def add_skin(self, name: str | None = None, file: str | None = None, material: str | None = None, rgba: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, inflate: typing.SupportsFloat | typing.SupportsIndex | None = None, group: typing.SupportsInt | typing.SupportsIndex | None = None, vert: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, texcoord: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, face: collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex] | None = None, bodyname: collections.abc.Sequence[str] | None = None, bindpos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, bindquat: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, vertid: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex]] | None = None, vertweight: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex]] | None = None, info: str | None = None) -> MjsSkin:
+        """
+              Add skin to spec.
+        
+              Args:
+                name: str
+                file: str
+                material: str
+                rgba: list[float]
+                inflate: float
+                group: int
+                vert: list[float]
+                texcoord: list[float]
+                face: list[int]
+                bodyname: list[str]
+                bindpos: list[float]
+                bindquat: list[float]
+                vertid: list[list[int]]
+                vertweight: list[list[float]]
+                info: str
+        """
+    def add_tendon(self, default: MjsDefault = None, name: str | None = None, stiffness: typing.Any | None = None, springlength: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, damping: typing.Any | None = None, frictionloss: typing.SupportsFloat | typing.SupportsIndex | None = None, solref_friction: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, solimp_friction: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, armature: typing.SupportsFloat | typing.SupportsIndex | None = None, limited: typing.SupportsInt | typing.SupportsIndex | None = None, actfrclimited: typing.SupportsInt | typing.SupportsIndex | None = None, range: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, actfrcrange: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, margin: typing.SupportsFloat | typing.SupportsIndex | None = None, solref_limit: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, solimp_limit: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, material: str | None = None, width: typing.SupportsFloat | typing.SupportsIndex | None = None, rgba: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, group: typing.SupportsInt | typing.SupportsIndex | None = None, userdata: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsTendon:
+        """
+              Add tendon to spec.
+        
+              Args:
+                name: str
+                stiffness: Optional[list[float]]
+                springlength: list[float]
+                damping: Optional[list[float]]
+                frictionloss: float
+                solref_friction: list[float]
+                solimp_friction: list[float]
+                armature: float
+                limited: int
+                actfrclimited: int
+                range: list[float]
+                actfrcrange: list[float]
+                margin: float
+                solref_limit: list[float]
+                solimp_limit: list[float]
+                material: str
+                width: float
+                rgba: list[float]
+                group: int
+                userdata: list[float]
+                info: str
+        """
+    def add_text(self, name: str | None = None, data: str | None = None, info: str | None = None) -> MjsText:
+        """
+              Add text to spec.
+        
+              Args:
+                name: str
+                data: str
+                info: str
+        """
+    def add_texture(self, name: str | None = None, type: typing.SupportsInt | typing.SupportsIndex | None = None, colorspace: typing.SupportsInt | typing.SupportsIndex | None = None, builtin: typing.SupportsInt | typing.SupportsIndex | None = None, mark: typing.SupportsInt | typing.SupportsIndex | None = None, rgb1: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, rgb2: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, markrgb: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, random: typing.SupportsFloat | typing.SupportsIndex | None = None, height: typing.SupportsInt | typing.SupportsIndex | None = None, width: typing.SupportsInt | typing.SupportsIndex | None = None, nchannel: typing.SupportsInt | typing.SupportsIndex | None = None, content_type: str | None = None, file: str | None = None, gridsize: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, gridlayout: typing.Any = None, cubefiles: collections.abc.Sequence[str] | None = None, data: collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex] | None = None, hflip: typing.SupportsInt | typing.SupportsIndex | None = None, vflip: typing.SupportsInt | typing.SupportsIndex | None = None, info: str | None = None) -> MjsTexture:
+        """
+              Add texture to spec.
+        
+              Args:
+                name: str
+                type: int
+                colorspace: int
+                builtin: int
+                mark: int
+                rgb1: list[float]
+                rgb2: list[float]
+                markrgb: list[float]
+                random: float
+                height: int
+                width: int
+                nchannel: int
+                content_type: str
+                file: str
+                gridsize: list[float]
+                gridlayout: str | list[str]
+                cubefiles: list[str]
+                data: list[int]
+                hflip: int
+                vflip: int
+                info: str
+        """
+    def add_tuple(self, name: str | None = None, objtype: collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex] | None = None, objname: collections.abc.Sequence[str] | None = None, objprm: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsTuple:
+        """
+              Add tuple to spec.
+        
+              Args:
+                name: str
+                objtype: list[int]
+                objname: list[str]
+                objprm: list[float]
+                info: str
+        """
+    def attach(self, child: MjSpec, prefix: str | None = None, suffix: str | None = None, site: typing.Any | None = None, frame: typing.Any | None = None) -> MjsFrame:
+        ...
+    def body(self, arg0: str) -> MjsBody:
+        ...
+    def camera(self, arg0: str) -> MjsCamera:
+        ...
+    def compile(self, vfs: mujoco._specs.MjVfs | None = None) -> typing.Any:
+        ...
+    def copy(self) -> MjSpec:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsDefault) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsBody) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsFrame) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsGeom) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsJoint) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsSite) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsCamera) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsLight) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsMaterial) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsMesh) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsPair) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsEquality) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsActuator) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsTendon) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsSensor) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsFlex) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsHField) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsSkin) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsTexture) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsKey) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsText) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsNumeric) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsExclude) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsTuple) -> None:
+        ...
+    @typing.overload
+    def delete(self, arg0: MjsPlugin) -> None:
+        ...
+    def encode(self, filename: str, model: typing.Any | None = None, content_type: str | None = None) -> int:
+        ...
+    def equality(self, arg0: str) -> MjsEquality:
+        ...
+    def exclude(self, arg0: str) -> MjsExclude:
+        ...
+    def find_default(self, arg0: str) -> MjsDefault:
+        ...
+    def flex(self, arg0: str) -> MjsFlex:
+        ...
+    def frame(self, arg0: str) -> MjsFrame:
+        ...
+    def geom(self, arg0: str) -> MjsGeom:
+        ...
+    def hfield(self, arg0: str) -> MjsHField:
+        ...
+    def joint(self, arg0: str) -> MjsJoint:
+        ...
+    def key(self, arg0: str) -> MjsKey:
+        ...
+    def light(self, arg0: str) -> MjsLight:
+        ...
+    def material(self, arg0: str) -> MjsMaterial:
+        ...
+    def mesh(self, arg0: str) -> MjsMesh:
+        ...
+    def numeric(self, arg0: str) -> MjsNumeric:
+        ...
+    def pair(self, arg0: str) -> MjsPair:
+        ...
+    def plugin(self, arg0: str) -> MjsPlugin:
+        ...
+    def recompile(self, arg0: typing.Any, arg1: typing.Any) -> typing.Any:
+        ...
+    def sensor(self, arg0: str) -> MjsSensor:
+        ...
+    def site(self, arg0: str) -> MjsSite:
+        ...
+    def skin(self, arg0: str) -> MjsSkin:
+        ...
+    def tendon(self, arg0: str) -> MjsTendon:
+        ...
+    def text(self, arg0: str) -> MjsText:
+        ...
+    def texture(self, arg0: str) -> MjsTexture:
+        ...
+    def to_file(self, arg0: str) -> None:
+        ...
+    def to_xml(self) -> str:
+        ...
+    def tuple(self, arg0: str) -> MjsTuple:
+        ...
+    @property
+    def _address(self) -> int:
+        ...
+    @property
+    def actuators(self) -> list:
+        ...
+    @property
+    def bodies(self) -> list:
+        ...
+    @property
+    def cameras(self) -> list:
+        ...
+    @property
+    def copy_during_attach(self) -> None:
+        ...
+    @copy_during_attach.setter
+    def copy_during_attach(self, arg1: bool) -> int:
+        ...
+    @property
+    def default(self) -> MjsDefault:
+        ...
+    @property
+    def equalities(self) -> list:
+        ...
+    @property
+    def excludes(self) -> list:
+        ...
+    @property
+    def flexes(self) -> list:
+        ...
+    @property
+    def frames(self) -> list:
+        ...
+    @property
+    def geoms(self) -> list:
+        ...
+    @property
+    def hfields(self) -> list:
+        ...
+    @property
+    def joints(self) -> list:
+        ...
+    @property
+    def keys(self) -> list:
+        ...
+    @property
+    def lights(self) -> list:
+        ...
+    @property
+    def materials(self) -> list:
+        ...
+    @property
+    def memory(self) -> int:
+        ...
+    @memory.setter
+    def memory(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def meshes(self) -> list:
+        ...
+    @property
+    def nconmax(self) -> int:
+        ...
+    @nconmax.setter
+    def nconmax(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nemax(self) -> int:
+        ...
+    @nemax.setter
+    def nemax(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def njmax(self) -> int:
+        ...
+    @njmax.setter
+    def njmax(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nkey(self) -> int:
+        ...
+    @nkey.setter
+    def nkey(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nstack(self) -> int:
+        ...
+    @nstack.setter
+    def nstack(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def numerics(self) -> list:
+        ...
+    @property
+    def nuser_actuator(self) -> int:
+        ...
+    @nuser_actuator.setter
+    def nuser_actuator(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nuser_body(self) -> int:
+        ...
+    @nuser_body.setter
+    def nuser_body(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nuser_cam(self) -> int:
+        ...
+    @nuser_cam.setter
+    def nuser_cam(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nuser_geom(self) -> int:
+        ...
+    @nuser_geom.setter
+    def nuser_geom(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nuser_jnt(self) -> int:
+        ...
+    @nuser_jnt.setter
+    def nuser_jnt(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nuser_sensor(self) -> int:
+        ...
+    @nuser_sensor.setter
+    def nuser_sensor(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nuser_site(self) -> int:
+        ...
+    @nuser_site.setter
+    def nuser_site(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nuser_tendon(self) -> int:
+        ...
+    @nuser_tendon.setter
+    def nuser_tendon(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nuserdata(self) -> int:
+        ...
+    @nuserdata.setter
+    def nuserdata(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def pairs(self) -> list:
+        ...
+    @property
+    def parent(self) -> MjSpec:
+        ...
+    @property
+    def plugins(self) -> list:
+        ...
+    @property
+    def sensors(self) -> list:
+        ...
+    @property
+    def sites(self) -> list:
+        ...
+    @property
+    def skins(self) -> list:
+        ...
+    @property
+    def tendons(self) -> list:
+        ...
+    @property
+    def texts(self) -> list:
+        ...
+    @property
+    def textures(self) -> list:
+        ...
+    @property
+    def timer(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[9, 1]", "flags.writeable"]:
+        ...
+    @property
+    def tuples(self) -> list:
+        ...
+    @property
+    def worldbody(self) -> MjsBody:
+        ...
+class MjStatistic:
+    @property
+    def center(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @center.setter
+    def center(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def extent(self) -> float:
+        ...
+    @extent.setter
+    def extent(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def meaninertia(self) -> float:
+        ...
+    @meaninertia.setter
+    def meaninertia(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def meanmass(self) -> float:
+        ...
+    @meanmass.setter
+    def meanmass(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def meansize(self) -> float:
+        ...
+    @meansize.setter
+    def meansize(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+class MjStringVec:
+    def __getitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> str:
+        ...
+    def __init__(self, arg0: str, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __iter__(self) -> collections.abc.Iterator[str]:
+        ...
+    def __len__(self) -> int:
+        ...
+    def __setitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex, arg1: str) -> None:
+        ...
+class MjVfs:
+    def __contains__(self, arg0: str) -> bool:
+        ...
+    def __delitem__(self, arg0: str) -> None:
+        ...
+    def __enter__(self) -> MjVfs:
+        ...
+    def __exit__(self, arg0: typing.Any, arg1: typing.Any, arg2: typing.Any) -> None:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __setitem__(self, arg0: str, arg1: bytes) -> None:
+        ...
+    def close(self) -> None:
+        ...
+class MjVisual:
+    global: mujoco._structs.MjVisual.Global
+    global_: mujoco._structs.MjVisual.Global
+    headlight: MjVisualHeadlight
+    map: mujoco._structs.MjVisual.Map
+    quality: mujoco._structs.MjVisual.Quality
+    rgba: MjVisualRgba
+    scale: mujoco._structs.MjVisual.Scale
+class MjVisualHeadlight:
+    @property
+    def active(self) -> int:
+        ...
+    @active.setter
+    def active(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def ambient(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[3, 1]", "flags.writeable"]:
+        ...
+    @ambient.setter
+    def ambient(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[3, 1]"]) -> None:
+        ...
+    @property
+    def diffuse(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[3, 1]", "flags.writeable"]:
+        ...
+    @diffuse.setter
+    def diffuse(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[3, 1]"]) -> None:
+        ...
+    @property
+    def specular(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[3, 1]", "flags.writeable"]:
+        ...
+    @specular.setter
+    def specular(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[3, 1]"]) -> None:
+        ...
+class MjVisualRgba:
+    @property
+    def actuator(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @actuator.setter
+    def actuator(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def actuatornegative(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @actuatornegative.setter
+    def actuatornegative(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def actuatorpositive(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @actuatorpositive.setter
+    def actuatorpositive(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def bv(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @bv.setter
+    def bv(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def bvactive(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @bvactive.setter
+    def bvactive(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def camera(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @camera.setter
+    def camera(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def com(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @com.setter
+    def com(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def connect(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @connect.setter
+    def connect(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def constraint(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @constraint.setter
+    def constraint(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def contactforce(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @contactforce.setter
+    def contactforce(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def contactfriction(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @contactfriction.setter
+    def contactfriction(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def contactgap(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @contactgap.setter
+    def contactgap(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def contactpoint(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @contactpoint.setter
+    def contactpoint(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def contacttorque(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @contacttorque.setter
+    def contacttorque(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def crankbroken(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @crankbroken.setter
+    def crankbroken(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def fog(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @fog.setter
+    def fog(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def force(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @force.setter
+    def force(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def frustum(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @frustum.setter
+    def frustum(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def haze(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @haze.setter
+    def haze(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def inertia(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @inertia.setter
+    def inertia(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def joint(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @joint.setter
+    def joint(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def light(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @light.setter
+    def light(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def rangefinder(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @rangefinder.setter
+    def rangefinder(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def selectpoint(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @selectpoint.setter
+    def selectpoint(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def slidercrank(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @slidercrank.setter
+    def slidercrank(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+class MjsActuator:
+    actearly: bool
+    classname: MjsDefault
+    info: str
+    name: str
+    plugin: MjsPlugin
+    refsite: str
+    slidersite: str
+    target: str
+    def set_to_adhesion(self, gain: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    def set_to_cylinder(self, timeconst: typing.SupportsFloat | typing.SupportsIndex, bias: typing.SupportsFloat | typing.SupportsIndex, area: typing.SupportsFloat | typing.SupportsIndex, diameter: typing.SupportsFloat | typing.SupportsIndex = -1) -> None:
+        ...
+    def set_to_damper(self, kv: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    def set_to_dcmotor(self, motorconst: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex], "FixedSize(2)"], resistance: typing.SupportsFloat | typing.SupportsIndex, nominal: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex], "FixedSize(3)"] = [0.0, 0.0, 0.0], saturation: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex], "FixedSize(3)"] = [0.0, 0.0, 0.0], inductance: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex], "FixedSize(2)"] = [0.0, 0.0], cogging: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex], "FixedSize(3)"] = [0.0, 0.0, 0.0], controller: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex], "FixedSize(6)"] = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0], thermal: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex], "FixedSize(6)"] = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0], lugre: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex], "FixedSize(5)"] = [0.0, 0.0, 0.0, 0.0, 0.0], input_mode: typing.SupportsInt | typing.SupportsIndex = 0) -> None:
+        ...
+    def set_to_intvelocity(self, kp: typing.SupportsFloat | typing.SupportsIndex, kv: typing.SupportsFloat | typing.SupportsIndex = -1, dampratio: typing.SupportsFloat | typing.SupportsIndex = -1, timeconst: typing.SupportsFloat | typing.SupportsIndex = -1, inheritrange: bool = False) -> None:
+        ...
+    def set_to_motor(self) -> None:
+        ...
+    def set_to_muscle(self, timeconst: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex], "FixedSize(2)"] = [-1.0, -1.0], tausmooth: typing.SupportsFloat | typing.SupportsIndex, range: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex], "FixedSize(2)"] = [-1.0, -1.0], force: typing.SupportsFloat | typing.SupportsIndex = -1, scale: typing.SupportsFloat | typing.SupportsIndex = -1, lmin: typing.SupportsFloat | typing.SupportsIndex = -1, lmax: typing.SupportsFloat | typing.SupportsIndex = -1, vmax: typing.SupportsFloat | typing.SupportsIndex = -1, fpmax: typing.SupportsFloat | typing.SupportsIndex = -1, fvmax: typing.SupportsFloat | typing.SupportsIndex = -1) -> None:
+        ...
+    def set_to_orientation(self, kp: typing.SupportsFloat | typing.SupportsIndex, kv: typing.SupportsFloat | typing.SupportsIndex = -1, dampratio: typing.SupportsFloat | typing.SupportsIndex = -1, ctrlspec: typing.SupportsInt | typing.SupportsIndex = 0) -> None:
+        ...
+    def set_to_position(self, kp: typing.SupportsFloat | typing.SupportsIndex, kv: typing.SupportsFloat | typing.SupportsIndex = -1, dampratio: typing.SupportsFloat | typing.SupportsIndex = -1, timeconst: typing.SupportsFloat | typing.SupportsIndex = -1, inheritrange: bool = False) -> None:
+        ...
+    def set_to_velocity(self, kv: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def actdim(self) -> int:
+        ...
+    @actdim.setter
+    def actdim(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def actlimited(self) -> mujoco._enums.mjtLimited:
+        ...
+    @actlimited.setter
+    def actlimited(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def actrange(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @actrange.setter
+    def actrange(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def armature(self) -> float:
+        ...
+    @armature.setter
+    def armature(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def biasprm(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[10, 1]", "flags.writeable"]:
+        ...
+    @biasprm.setter
+    def biasprm(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[10, 1]"]) -> None:
+        ...
+    @property
+    def biastype(self) -> mujoco._enums.mjtBias:
+        ...
+    @biastype.setter
+    def biastype(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def cranklength(self) -> float:
+        ...
+    @cranklength.setter
+    def cranklength(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def ctrllimited(self) -> mujoco._enums.mjtLimited:
+        ...
+    @ctrllimited.setter
+    def ctrllimited(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def ctrlrange(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @ctrlrange.setter
+    def ctrlrange(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def ctrlspec(self) -> int:
+        ...
+    @ctrlspec.setter
+    def ctrlspec(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def damping(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @damping.setter
+    def damping(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def delay(self) -> float:
+        ...
+    @delay.setter
+    def delay(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def dynprm(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[10, 1]", "flags.writeable"]:
+        ...
+    @dynprm.setter
+    def dynprm(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[10, 1]"]) -> None:
+        ...
+    @property
+    def dyntype(self) -> mujoco._enums.mjtDyn:
+        ...
+    @dyntype.setter
+    def dyntype(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def forcelimited(self) -> mujoco._enums.mjtLimited:
+        ...
+    @forcelimited.setter
+    def forcelimited(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def forcerange(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @forcerange.setter
+    def forcerange(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def gainprm(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[10, 1]", "flags.writeable"]:
+        ...
+    @gainprm.setter
+    def gainprm(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[10, 1]"]) -> None:
+        ...
+    @property
+    def gaintype(self) -> mujoco._enums.mjtGain:
+        ...
+    @gaintype.setter
+    def gaintype(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def gear(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]", "flags.writeable"]:
+        ...
+    @gear.setter
+    def gear(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]"]) -> None:
+        ...
+    @property
+    def group(self) -> int:
+        ...
+    @group.setter
+    def group(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def inheritrange(self) -> float:
+        ...
+    @inheritrange.setter
+    def inheritrange(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def interp(self) -> int:
+        ...
+    @interp.setter
+    def interp(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def lengthrange(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @lengthrange.setter
+    def lengthrange(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def nsample(self) -> int:
+        ...
+    @nsample.setter
+    def nsample(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def trntype(self) -> mujoco._enums.mjtTrn:
+        ...
+    @trntype.setter
+    def trntype(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def userdata(self) -> MjDoubleVec:
+        ...
+    @userdata.setter
+    def userdata(self, arg1: typing.Any) -> None:
+        ...
+class MjsAuthored:
+    @property
+    def disableactuator(self) -> int:
+        ...
+    @disableactuator.setter
+    def disableactuator(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def disableflags(self) -> int:
+        ...
+    @disableflags.setter
+    def disableflags(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def enableflags(self) -> int:
+        ...
+    @enableflags.setter
+    def enableflags(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def option(self) -> int:
+        ...
+    @option.setter
+    def option(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def visual_global(self) -> int:
+        ...
+    @visual_global.setter
+    def visual_global(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def visual_headlight(self) -> int:
+        ...
+    @visual_headlight.setter
+    def visual_headlight(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def visual_map(self) -> int:
+        ...
+    @visual_map.setter
+    def visual_map(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def visual_quality(self) -> int:
+        ...
+    @visual_quality.setter
+    def visual_quality(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def visual_rgba(self) -> int:
+        ...
+    @visual_rgba.setter
+    def visual_rgba(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def visual_scale(self) -> int:
+        ...
+    @visual_scale.setter
+    def visual_scale(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjsBody:
+    alt: MjsOrientation
+    childclass: str
+    classname: MjsDefault
+    explicitinertial: bool
+    ialt: MjsOrientation
+    info: str
+    mocap: bool
+    name: str
+    plugin: MjsPlugin
+    def add_body(self, default: MjsDefault = None, name: str | None = None, childclass: str | None = None, pos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, quat: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, axisangle: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, xyaxes: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, zaxis: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, euler: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, mass: typing.SupportsFloat | typing.SupportsIndex | None = None, ipos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, iquat: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, inertia: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, iaxisangle: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, ixyaxes: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, izaxis: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, ieuler: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, fullinertia: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, mocap: typing.SupportsInt | typing.SupportsIndex | None = None, gravcomp: typing.SupportsFloat | typing.SupportsIndex | None = None, sleep: typing.SupportsInt | typing.SupportsIndex | None = None, simple: typing.SupportsInt | typing.SupportsIndex | None = None, userdata: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, explicitinertial: typing.SupportsInt | typing.SupportsIndex | None = None, plugin: mujoco._specs.MjsPlugin | None = None, info: str | None = None) -> MjsBody:
+        """
+              Add body to spec.
+        
+              Args:
+                name: str
+                childclass: str
+                pos: list[float]
+                quat: list[float]
+                axisangle: list[float]
+                xyaxes: list[float]
+                zaxis: list[float]
+                euler: list[float]
+                mass: float
+                ipos: list[float]
+                iquat: list[float]
+                inertia: list[float]
+                iaxisangle: list[float]
+                ixyaxes: list[float]
+                izaxis: list[float]
+                ieuler: list[float]
+                fullinertia: list[float]
+                mocap: int
+                gravcomp: float
+                sleep: int
+                simple: int
+                userdata: list[float]
+                explicitinertial: int
+                plugin: MjsPlugin
+                info: str
+        """
+    def add_camera(self, default: MjsDefault = None, name: str | None = None, pos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, quat: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, axisangle: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, xyaxes: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, zaxis: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, euler: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, mode: typing.SupportsInt | typing.SupportsIndex | None = None, targetbody: str | None = None, proj: typing.SupportsInt | typing.SupportsIndex | None = None, resolution: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, output: typing.SupportsInt | typing.SupportsIndex | None = None, fovy: typing.SupportsFloat | typing.SupportsIndex | None = None, ipd: typing.SupportsFloat | typing.SupportsIndex | None = None, intrinsic: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, sensor_size: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, focal_length: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, focal_pixel: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, principal_length: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, principal_pixel: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, userdata: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsCamera:
+        """
+              Add camera to spec.
+        
+              Args:
+                name: str
+                pos: list[float]
+                quat: list[float]
+                axisangle: list[float]
+                xyaxes: list[float]
+                zaxis: list[float]
+                euler: list[float]
+                mode: int
+                targetbody: str
+                proj: int
+                resolution: list[float]
+                output: int
+                fovy: float
+                ipd: float
+                intrinsic: list[float]
+                sensor_size: list[float]
+                focal_length: list[float]
+                focal_pixel: list[float]
+                principal_length: list[float]
+                principal_pixel: list[float]
+                userdata: list[float]
+                info: str
+        """
+    def add_frame(self, default: MjsFrame = None, name: str | None = None, childclass: str | None = None, pos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, quat: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, axisangle: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, xyaxes: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, zaxis: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, euler: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsFrame:
+        """
+              Add frame to spec.
+        
+              Args:
+                name: str
+                childclass: str
+                pos: list[float]
+                quat: list[float]
+                axisangle: list[float]
+                xyaxes: list[float]
+                zaxis: list[float]
+                euler: list[float]
+                info: str
+        """
+    def add_freejoint(self, **kwargs) -> MjsJoint:
+        ...
+    def add_geom(self, default: MjsDefault = None, name: str | None = None, type: typing.SupportsInt | typing.SupportsIndex | None = None, pos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, quat: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, axisangle: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, xyaxes: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, zaxis: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, euler: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, fromto: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, size: typing.Any | None = None, contype: typing.SupportsInt | typing.SupportsIndex | None = None, conaffinity: typing.SupportsInt | typing.SupportsIndex | None = None, condim: typing.SupportsInt | typing.SupportsIndex | None = None, priority: typing.SupportsInt | typing.SupportsIndex | None = None, friction: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, solmix: typing.SupportsFloat | typing.SupportsIndex | None = None, solref: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, solimp: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, margin: typing.SupportsFloat | typing.SupportsIndex | None = None, gap: typing.SupportsFloat | typing.SupportsIndex | None = None, surfacevel: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, adhesion: typing.SupportsFloat | typing.SupportsIndex | None = None, mass: typing.SupportsFloat | typing.SupportsIndex | None = None, density: typing.SupportsFloat | typing.SupportsIndex | None = None, typeinertia: typing.SupportsInt | typing.SupportsIndex | None = None, fluid_ellipsoid: typing.SupportsInt | typing.SupportsIndex | None = None, fluid_coefs: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, material: str | None = None, rgba: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, group: typing.SupportsInt | typing.SupportsIndex | None = None, hfieldname: str | None = None, meshname: str | None = None, fitscale: typing.SupportsFloat | typing.SupportsIndex | None = None, userdata: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, plugin: mujoco._specs.MjsPlugin | None = None, info: str | None = None) -> MjsGeom:
+        """
+              Add geom to spec.
+        
+              Args:
+                name: str
+                type: int
+                pos: list[float]
+                quat: list[float]
+                axisangle: list[float]
+                xyaxes: list[float]
+                zaxis: list[float]
+                euler: list[float]
+                fromto: list[float]
+                size: Optional[list[float]]
+                contype: int
+                conaffinity: int
+                condim: int
+                priority: int
+                friction: list[float]
+                solmix: float
+                solref: list[float]
+                solimp: list[float]
+                margin: float
+                gap: float
+                surfacevel: list[float]
+                adhesion: float
+                mass: float
+                density: float
+                typeinertia: int
+                fluid_ellipsoid: int
+                fluid_coefs: list[float]
+                material: str
+                rgba: list[float]
+                group: int
+                hfieldname: str
+                meshname: str
+                fitscale: float
+                userdata: list[float]
+                plugin: MjsPlugin
+                info: str
+        """
+    def add_joint(self, default: MjsDefault = None, name: str | None = None, type: typing.SupportsInt | typing.SupportsIndex | None = None, pos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, axis: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, ref: typing.SupportsFloat | typing.SupportsIndex | None = None, align: typing.SupportsInt | typing.SupportsIndex | None = None, stiffness: typing.Any | None = None, springref: typing.SupportsFloat | typing.SupportsIndex | None = None, springdamper: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, limited: typing.SupportsInt | typing.SupportsIndex | None = None, range: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, margin: typing.SupportsFloat | typing.SupportsIndex | None = None, solref_limit: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, solimp_limit: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, actfrclimited: typing.SupportsInt | typing.SupportsIndex | None = None, actfrcrange: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, armature: typing.SupportsFloat | typing.SupportsIndex | None = None, damping: typing.Any | None = None, frictionloss: typing.SupportsFloat | typing.SupportsIndex | None = None, solref_friction: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, solimp_friction: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, group: typing.SupportsInt | typing.SupportsIndex | None = None, actgravcomp: typing.SupportsInt | typing.SupportsIndex | None = None, userdata: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsJoint:
+        """
+              Add joint to spec.
+        
+              Args:
+                name: str
+                type: int
+                pos: list[float]
+                axis: list[float]
+                ref: float
+                align: int
+                stiffness: Optional[list[float]]
+                springref: float
+                springdamper: list[float]
+                limited: int
+                range: list[float]
+                margin: float
+                solref_limit: list[float]
+                solimp_limit: list[float]
+                actfrclimited: int
+                actfrcrange: list[float]
+                armature: float
+                damping: Optional[list[float]]
+                frictionloss: float
+                solref_friction: list[float]
+                solimp_friction: list[float]
+                group: int
+                actgravcomp: int
+                userdata: list[float]
+                info: str
+        """
+    def add_light(self, default: MjsDefault = None, name: str | None = None, pos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, dir: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, mode: typing.SupportsInt | typing.SupportsIndex | None = None, targetbody: str | None = None, active: typing.SupportsInt | typing.SupportsIndex | None = None, type: typing.SupportsInt | typing.SupportsIndex | None = None, texture: str | None = None, castshadow: typing.SupportsInt | typing.SupportsIndex | None = None, bulbradius: typing.SupportsFloat | typing.SupportsIndex | None = None, intensity: typing.SupportsFloat | typing.SupportsIndex | None = None, range: typing.SupportsFloat | typing.SupportsIndex | None = None, attenuation: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, cutoff: typing.SupportsFloat | typing.SupportsIndex | None = None, exponent: typing.SupportsFloat | typing.SupportsIndex | None = None, ambient: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, diffuse: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, specular: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsLight:
+        """
+              Add light to spec.
+        
+              Args:
+                name: str
+                pos: list[float]
+                dir: list[float]
+                mode: int
+                targetbody: str
+                active: int
+                type: int
+                texture: str
+                castshadow: int
+                bulbradius: float
+                intensity: float
+                range: float
+                attenuation: list[float]
+                cutoff: float
+                exponent: float
+                ambient: list[float]
+                diffuse: list[float]
+                specular: list[float]
+                info: str
+        """
+    def add_site(self, default: MjsDefault = None, name: str | None = None, pos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, quat: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, axisangle: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, xyaxes: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, zaxis: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, euler: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, fromto: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, size: typing.Any | None = None, type: typing.SupportsInt | typing.SupportsIndex | None = None, material: str | None = None, group: typing.SupportsInt | typing.SupportsIndex | None = None, rgba: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, userdata: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsSite:
+        """
+              Add site to spec.
+        
+              Args:
+                name: str
+                pos: list[float]
+                quat: list[float]
+                axisangle: list[float]
+                xyaxes: list[float]
+                zaxis: list[float]
+                euler: list[float]
+                fromto: list[float]
+                size: Optional[list[float]]
+                type: int
+                material: str
+                group: int
+                rgba: list[float]
+                userdata: list[float]
+                info: str
+        """
+    def attach_frame(self, frame: MjsFrame, prefix: str | None = None, suffix: str | None = None) -> MjsFrame:
+        ...
+    @typing.overload
+    def find_all(self, arg0: mujoco._enums.mjtObj) -> list:
+        ...
+    @typing.overload
+    def find_all(self, arg0: str) -> list:
+        ...
+    def find_child(self, arg0: str) -> MjsBody:
+        ...
+    def first_body(self) -> MjsBody:
+        ...
+    def first_camera(self) -> MjsCamera:
+        ...
+    def first_frame(self) -> MjsFrame:
+        ...
+    def first_geom(self) -> MjsGeom:
+        ...
+    def first_joint(self) -> MjsJoint:
+        ...
+    def first_light(self) -> MjsLight:
+        ...
+    def first_site(self) -> MjsSite:
+        ...
+    def make_flex(self, name: str, type: str | None = None, dim: typing.SupportsInt | typing.SupportsIndex = 3, dof: str | None = None, count: collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex] | None = None, cellcount: collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex] | None = None, spacing: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, scale: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, radius: typing.SupportsFloat | typing.SupportsIndex = 0.0, mass: typing.SupportsFloat | typing.SupportsIndex = 1.0, inertiabox: typing.SupportsFloat | typing.SupportsIndex = 0.005, equality: typing.SupportsInt | typing.SupportsIndex = 0, rigid: typing.SupportsInt | typing.SupportsIndex = 0, flatskin: typing.SupportsInt | typing.SupportsIndex = 0, elastic2d: typing.SupportsInt | typing.SupportsIndex = 0, pos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, quat: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, origin: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, file: str | None = None, vfs: MjVfs = None) -> MjsFlex:
+        ...
+    def next_body(self, arg0: MjsBody) -> MjsBody:
+        ...
+    def next_camera(self, arg0: MjsCamera) -> MjsCamera:
+        ...
+    def next_frame(self, arg0: MjsFrame) -> MjsFrame:
+        ...
+    def next_geom(self, arg0: MjsGeom) -> MjsGeom:
+        ...
+    def next_joint(self, arg0: MjsJoint) -> MjsJoint:
+        ...
+    def next_light(self, arg0: MjsLight) -> MjsLight:
+        ...
+    def next_site(self, arg0: MjsSite) -> MjsSite:
+        ...
+    def set_frame(self, arg0: MjsFrame) -> None:
+        ...
+    def to_frame(self) -> MjsFrame:
+        ...
+    @property
+    def bodies(self) -> list:
+        ...
+    @property
+    def cameras(self) -> list:
+        ...
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def frame(self) -> MjsFrame:
+        ...
+    @property
+    def frames(self) -> list:
+        ...
+    @property
+    def fullinertia(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]", "flags.writeable"]:
+        ...
+    @fullinertia.setter
+    def fullinertia(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]"]) -> None:
+        ...
+    @property
+    def geoms(self) -> list:
+        ...
+    @property
+    def gravcomp(self) -> float:
+        ...
+    @gravcomp.setter
+    def gravcomp(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def inertia(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @inertia.setter
+    def inertia(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def ipos(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @ipos.setter
+    def ipos(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def iquat(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"]:
+        ...
+    @iquat.setter
+    def iquat(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"]) -> None:
+        ...
+    @property
+    def joints(self) -> list:
+        ...
+    @property
+    def lights(self) -> list:
+        ...
+    @property
+    def mass(self) -> float:
+        ...
+    @mass.setter
+    def mass(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def parent(self) -> MjsBody:
+        ...
+    @property
+    def pos(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def quat(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"]:
+        ...
+    @quat.setter
+    def quat(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"]) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def simple(self) -> int:
+        ...
+    @simple.setter
+    def simple(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def sites(self) -> list:
+        ...
+    @property
+    def sleep(self) -> mujoco._enums.mjtSleepPolicy:
+        ...
+    @sleep.setter
+    def sleep(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def userdata(self) -> MjDoubleVec:
+        ...
+    @userdata.setter
+    def userdata(self, arg1: typing.Any) -> None:
+        ...
+class MjsCamera:
+    alt: MjsOrientation
+    classname: MjsDefault
+    info: str
+    name: str
+    targetbody: str
+    def set_frame(self, arg0: MjsFrame) -> None:
+        ...
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def focal_length(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[2, 1]", "flags.writeable"]:
+        ...
+    @focal_length.setter
+    def focal_length(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[2, 1]"]) -> None:
+        ...
+    @property
+    def focal_pixel(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[2, 1]", "flags.writeable"]:
+        ...
+    @focal_pixel.setter
+    def focal_pixel(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[2, 1]"]) -> None:
+        ...
+    @property
+    def fovy(self) -> float:
+        ...
+    @fovy.setter
+    def fovy(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def frame(self) -> MjsFrame:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def intrinsic(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @intrinsic.setter
+    def intrinsic(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def ipd(self) -> float:
+        ...
+    @ipd.setter
+    def ipd(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def mode(self) -> mujoco._enums.mjtCamLight:
+        ...
+    @mode.setter
+    def mode(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def output(self) -> int:
+        ...
+    @output.setter
+    def output(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def parent(self) -> MjsBody:
+        ...
+    @property
+    def pos(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def principal_length(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[2, 1]", "flags.writeable"]:
+        ...
+    @principal_length.setter
+    def principal_length(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[2, 1]"]) -> None:
+        ...
+    @property
+    def principal_pixel(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[2, 1]", "flags.writeable"]:
+        ...
+    @principal_pixel.setter
+    def principal_pixel(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[2, 1]"]) -> None:
+        ...
+    @property
+    def proj(self) -> mujoco._enums.mjtProjection:
+        ...
+    @proj.setter
+    def proj(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def quat(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"]:
+        ...
+    @quat.setter
+    def quat(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"]) -> None:
+        ...
+    @property
+    def resolution(self) -> typing.Annotated[numpy.typing.NDArray[numpy.int32], "[2, 1]", "flags.writeable"]:
+        ...
+    @resolution.setter
+    def resolution(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[2, 1]"]) -> None:
+        ...
+    @property
+    def sensor_size(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[2, 1]", "flags.writeable"]:
+        ...
+    @sensor_size.setter
+    def sensor_size(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[2, 1]"]) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def userdata(self) -> MjDoubleVec:
+        ...
+    @userdata.setter
+    def userdata(self, arg1: typing.Any) -> None:
+        ...
+class MjsCompiler:
+    LRopt: mujoco._structs.MjLROpt
+    alignfree: bool
+    autolimits: bool
+    balanceinertia: bool
+    degree: bool
+    discardvisual: bool
+    fitaabb: bool
+    fusestatic: bool
+    meshdir: str
+    saveinertial: bool
+    texturedir: str
+    usethread: bool
+    @property
+    def authored(self) -> int:
+        ...
+    @authored.setter
+    def authored(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def boundinertia(self) -> float:
+        ...
+    @boundinertia.setter
+    def boundinertia(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def boundmass(self) -> float:
+        ...
+    @boundmass.setter
+    def boundmass(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def conflict(self) -> mujoco._enums.mjtConflict:
+        ...
+    @conflict.setter
+    def conflict(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def eulerseq(self) -> MjCharVec:
+        ...
+    @eulerseq.setter
+    def eulerseq(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def inertiafromgeom(self) -> mujoco._enums.mjtInertiaFromGeom:
+        ...
+    @inertiafromgeom.setter
+    def inertiafromgeom(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def inertiagrouprange(self) -> typing.Annotated[numpy.typing.NDArray[numpy.int32], "[2, 1]", "flags.writeable"]:
+        ...
+    @inertiagrouprange.setter
+    def inertiagrouprange(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[2, 1]"]) -> None:
+        ...
+    @property
+    def settotalmass(self) -> float:
+        ...
+    @settotalmass.setter
+    def settotalmass(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+class MjsDefault:
+    actuator: MjsActuator
+    camera: MjsCamera
+    equality: MjsEquality
+    flex: MjsFlex
+    geom: MjsGeom
+    joint: MjsJoint
+    light: MjsLight
+    material: MjsMaterial
+    mesh: MjsMesh
+    name: str
+    pair: MjsPair
+    site: MjsSite
+    tendon: MjsTendon
+class MjsElement:
+    pass
+class MjsEquality:
+    active: bool
+    classname: MjsDefault
+    info: str
+    name: str
+    name1: str
+    name2: str
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def data(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[11, 1]", "flags.writeable"]:
+        ...
+    @data.setter
+    def data(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[11, 1]"]) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def objtype(self) -> mujoco._enums.mjtObj:
+        ...
+    @objtype.setter
+    def objtype(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def solimp(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]", "flags.writeable"]:
+        ...
+    @solimp.setter
+    def solimp(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]"]) -> None:
+        ...
+    @property
+    def solref(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @solref.setter
+    def solref(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def type(self) -> mujoco._enums.mjtEq:
+        ...
+    @type.setter
+    def type(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjsExclude:
+    bodyname1: str
+    bodyname2: str
+    info: str
+    name: str
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+class MjsFlex:
+    flatskin: bool
+    info: str
+    internal: bool
+    material: str
+    name: str
+    @property
+    def activelayers(self) -> int:
+        ...
+    @activelayers.setter
+    def activelayers(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def cellcount(self) -> typing.Annotated[numpy.typing.NDArray[numpy.int32], "[3, 1]", "flags.writeable"]:
+        ...
+    @cellcount.setter
+    def cellcount(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[3, 1]"]) -> None:
+        ...
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def conaffinity(self) -> int:
+        ...
+    @conaffinity.setter
+    def conaffinity(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def condim(self) -> int:
+        ...
+    @condim.setter
+    def condim(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def contype(self) -> int:
+        ...
+    @contype.setter
+    def contype(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def damping(self) -> float:
+        ...
+    @damping.setter
+    def damping(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def dim(self) -> int:
+        ...
+    @dim.setter
+    def dim(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def edgedamping(self) -> float:
+        ...
+    @edgedamping.setter
+    def edgedamping(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def edgestiffness(self) -> float:
+        ...
+    @edgestiffness.setter
+    def edgestiffness(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def elastic2d(self) -> int:
+        ...
+    @elastic2d.setter
+    def elastic2d(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def elem(self) -> MjIntVec:
+        ...
+    @elem.setter
+    def elem(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def elemtexcoord(self) -> MjIntVec:
+        ...
+    @elemtexcoord.setter
+    def elemtexcoord(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def friction(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @friction.setter
+    def friction(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def gap(self) -> float:
+        ...
+    @gap.setter
+    def gap(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def group(self) -> int:
+        ...
+    @group.setter
+    def group(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def margin(self) -> float:
+        ...
+    @margin.setter
+    def margin(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def node(self) -> MjDoubleVec:
+        ...
+    @node.setter
+    def node(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def nodebody(self) -> MjStringVec:
+        ...
+    @nodebody.setter
+    def nodebody(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def order(self) -> int:
+        ...
+    @order.setter
+    def order(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def passive(self) -> int:
+        ...
+    @passive.setter
+    def passive(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def poisson(self) -> float:
+        ...
+    @poisson.setter
+    def poisson(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def priority(self) -> int:
+        ...
+    @priority.setter
+    def priority(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def radius(self) -> float:
+        ...
+    @radius.setter
+    def radius(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def rgba(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @rgba.setter
+    def rgba(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def selfcollide(self) -> mujoco._enums.mjtFlexSelf:
+        ...
+    @selfcollide.setter
+    def selfcollide(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def size(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @size.setter
+    def size(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def solimp(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]", "flags.writeable"]:
+        ...
+    @solimp.setter
+    def solimp(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]"]) -> None:
+        ...
+    @property
+    def solmix(self) -> float:
+        ...
+    @solmix.setter
+    def solmix(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def solref(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @solref.setter
+    def solref(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def texcoord(self) -> MjFloatVec:
+        ...
+    @texcoord.setter
+    def texcoord(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def thickness(self) -> float:
+        ...
+    @thickness.setter
+    def thickness(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def vert(self) -> MjDoubleVec:
+        ...
+    @vert.setter
+    def vert(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def vertbody(self) -> MjStringVec:
+        ...
+    @vertbody.setter
+    def vertbody(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def young(self) -> float:
+        ...
+    @young.setter
+    def young(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+class MjsFrame:
+    alt: MjsOrientation
+    childclass: str
+    info: str
+    name: str
+    def add_body(self, default: MjsDefault = None, name: str | None = None, childclass: str | None = None, pos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, quat: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, axisangle: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, xyaxes: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, zaxis: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, euler: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, mass: typing.SupportsFloat | typing.SupportsIndex | None = None, ipos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, iquat: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, inertia: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, iaxisangle: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, ixyaxes: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, izaxis: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, ieuler: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, fullinertia: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, mocap: typing.SupportsInt | typing.SupportsIndex | None = None, gravcomp: typing.SupportsFloat | typing.SupportsIndex | None = None, sleep: typing.SupportsInt | typing.SupportsIndex | None = None, simple: typing.SupportsInt | typing.SupportsIndex | None = None, userdata: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, explicitinertial: typing.SupportsInt | typing.SupportsIndex | None = None, plugin: mujoco._specs.MjsPlugin | None = None, info: str | None = None) -> MjsBody:
+        """
+              Add body to spec.
+        
+              Args:
+                name: str
+                childclass: str
+                pos: list[float]
+                quat: list[float]
+                axisangle: list[float]
+                xyaxes: list[float]
+                zaxis: list[float]
+                euler: list[float]
+                mass: float
+                ipos: list[float]
+                iquat: list[float]
+                inertia: list[float]
+                iaxisangle: list[float]
+                ixyaxes: list[float]
+                izaxis: list[float]
+                ieuler: list[float]
+                fullinertia: list[float]
+                mocap: int
+                gravcomp: float
+                sleep: int
+                simple: int
+                userdata: list[float]
+                explicitinertial: int
+                plugin: MjsPlugin
+                info: str
+        """
+    def add_camera(self, default: MjsDefault = None, name: str | None = None, pos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, quat: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, axisangle: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, xyaxes: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, zaxis: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, euler: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, mode: typing.SupportsInt | typing.SupportsIndex | None = None, targetbody: str | None = None, proj: typing.SupportsInt | typing.SupportsIndex | None = None, resolution: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, output: typing.SupportsInt | typing.SupportsIndex | None = None, fovy: typing.SupportsFloat | typing.SupportsIndex | None = None, ipd: typing.SupportsFloat | typing.SupportsIndex | None = None, intrinsic: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, sensor_size: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, focal_length: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, focal_pixel: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, principal_length: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, principal_pixel: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, userdata: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsCamera:
+        """
+              Add camera to spec.
+        
+              Args:
+                name: str
+                pos: list[float]
+                quat: list[float]
+                axisangle: list[float]
+                xyaxes: list[float]
+                zaxis: list[float]
+                euler: list[float]
+                mode: int
+                targetbody: str
+                proj: int
+                resolution: list[float]
+                output: int
+                fovy: float
+                ipd: float
+                intrinsic: list[float]
+                sensor_size: list[float]
+                focal_length: list[float]
+                focal_pixel: list[float]
+                principal_length: list[float]
+                principal_pixel: list[float]
+                userdata: list[float]
+                info: str
+        """
+    def add_frame(self, default: MjsFrame = None, name: str | None = None, childclass: str | None = None, pos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, quat: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, axisangle: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, xyaxes: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, zaxis: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, euler: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsFrame:
+        """
+              Add frame to spec.
+        
+              Args:
+                name: str
+                childclass: str
+                pos: list[float]
+                quat: list[float]
+                axisangle: list[float]
+                xyaxes: list[float]
+                zaxis: list[float]
+                euler: list[float]
+                info: str
+        """
+    def add_geom(self, default: MjsDefault = None, name: str | None = None, type: typing.SupportsInt | typing.SupportsIndex | None = None, pos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, quat: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, axisangle: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, xyaxes: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, zaxis: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, euler: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, fromto: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, size: typing.Any | None = None, contype: typing.SupportsInt | typing.SupportsIndex | None = None, conaffinity: typing.SupportsInt | typing.SupportsIndex | None = None, condim: typing.SupportsInt | typing.SupportsIndex | None = None, priority: typing.SupportsInt | typing.SupportsIndex | None = None, friction: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, solmix: typing.SupportsFloat | typing.SupportsIndex | None = None, solref: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, solimp: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, margin: typing.SupportsFloat | typing.SupportsIndex | None = None, gap: typing.SupportsFloat | typing.SupportsIndex | None = None, surfacevel: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, adhesion: typing.SupportsFloat | typing.SupportsIndex | None = None, mass: typing.SupportsFloat | typing.SupportsIndex | None = None, density: typing.SupportsFloat | typing.SupportsIndex | None = None, typeinertia: typing.SupportsInt | typing.SupportsIndex | None = None, fluid_ellipsoid: typing.SupportsInt | typing.SupportsIndex | None = None, fluid_coefs: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, material: str | None = None, rgba: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, group: typing.SupportsInt | typing.SupportsIndex | None = None, hfieldname: str | None = None, meshname: str | None = None, fitscale: typing.SupportsFloat | typing.SupportsIndex | None = None, userdata: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, plugin: mujoco._specs.MjsPlugin | None = None, info: str | None = None) -> MjsGeom:
+        """
+              Add geom to spec.
+        
+              Args:
+                name: str
+                type: int
+                pos: list[float]
+                quat: list[float]
+                axisangle: list[float]
+                xyaxes: list[float]
+                zaxis: list[float]
+                euler: list[float]
+                fromto: list[float]
+                size: Optional[list[float]]
+                contype: int
+                conaffinity: int
+                condim: int
+                priority: int
+                friction: list[float]
+                solmix: float
+                solref: list[float]
+                solimp: list[float]
+                margin: float
+                gap: float
+                surfacevel: list[float]
+                adhesion: float
+                mass: float
+                density: float
+                typeinertia: int
+                fluid_ellipsoid: int
+                fluid_coefs: list[float]
+                material: str
+                rgba: list[float]
+                group: int
+                hfieldname: str
+                meshname: str
+                fitscale: float
+                userdata: list[float]
+                plugin: MjsPlugin
+                info: str
+        """
+    def add_joint(self, default: MjsDefault = None, name: str | None = None, type: typing.SupportsInt | typing.SupportsIndex | None = None, pos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, axis: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, ref: typing.SupportsFloat | typing.SupportsIndex | None = None, align: typing.SupportsInt | typing.SupportsIndex | None = None, stiffness: typing.Any | None = None, springref: typing.SupportsFloat | typing.SupportsIndex | None = None, springdamper: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, limited: typing.SupportsInt | typing.SupportsIndex | None = None, range: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, margin: typing.SupportsFloat | typing.SupportsIndex | None = None, solref_limit: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, solimp_limit: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, actfrclimited: typing.SupportsInt | typing.SupportsIndex | None = None, actfrcrange: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, armature: typing.SupportsFloat | typing.SupportsIndex | None = None, damping: typing.Any | None = None, frictionloss: typing.SupportsFloat | typing.SupportsIndex | None = None, solref_friction: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, solimp_friction: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, group: typing.SupportsInt | typing.SupportsIndex | None = None, actgravcomp: typing.SupportsInt | typing.SupportsIndex | None = None, userdata: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsJoint:
+        """
+              Add joint to spec.
+        
+              Args:
+                name: str
+                type: int
+                pos: list[float]
+                axis: list[float]
+                ref: float
+                align: int
+                stiffness: Optional[list[float]]
+                springref: float
+                springdamper: list[float]
+                limited: int
+                range: list[float]
+                margin: float
+                solref_limit: list[float]
+                solimp_limit: list[float]
+                actfrclimited: int
+                actfrcrange: list[float]
+                armature: float
+                damping: Optional[list[float]]
+                frictionloss: float
+                solref_friction: list[float]
+                solimp_friction: list[float]
+                group: int
+                actgravcomp: int
+                userdata: list[float]
+                info: str
+        """
+    def add_light(self, default: MjsDefault = None, name: str | None = None, pos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, dir: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, mode: typing.SupportsInt | typing.SupportsIndex | None = None, targetbody: str | None = None, active: typing.SupportsInt | typing.SupportsIndex | None = None, type: typing.SupportsInt | typing.SupportsIndex | None = None, texture: str | None = None, castshadow: typing.SupportsInt | typing.SupportsIndex | None = None, bulbradius: typing.SupportsFloat | typing.SupportsIndex | None = None, intensity: typing.SupportsFloat | typing.SupportsIndex | None = None, range: typing.SupportsFloat | typing.SupportsIndex | None = None, attenuation: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, cutoff: typing.SupportsFloat | typing.SupportsIndex | None = None, exponent: typing.SupportsFloat | typing.SupportsIndex | None = None, ambient: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, diffuse: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, specular: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsLight:
+        """
+              Add light to spec.
+        
+              Args:
+                name: str
+                pos: list[float]
+                dir: list[float]
+                mode: int
+                targetbody: str
+                active: int
+                type: int
+                texture: str
+                castshadow: int
+                bulbradius: float
+                intensity: float
+                range: float
+                attenuation: list[float]
+                cutoff: float
+                exponent: float
+                ambient: list[float]
+                diffuse: list[float]
+                specular: list[float]
+                info: str
+        """
+    def add_site(self, default: MjsDefault = None, name: str | None = None, pos: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, quat: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, axisangle: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, xyaxes: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, zaxis: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, euler: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, fromto: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, size: typing.Any | None = None, type: typing.SupportsInt | typing.SupportsIndex | None = None, material: str | None = None, group: typing.SupportsInt | typing.SupportsIndex | None = None, rgba: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, userdata: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex] | None = None, info: str | None = None) -> MjsSite:
+        """
+              Add site to spec.
+        
+              Args:
+                name: str
+                pos: list[float]
+                quat: list[float]
+                axisangle: list[float]
+                xyaxes: list[float]
+                zaxis: list[float]
+                euler: list[float]
+                fromto: list[float]
+                size: Optional[list[float]]
+                type: int
+                material: str
+                group: int
+                rgba: list[float]
+                userdata: list[float]
+                info: str
+        """
+    def attach_body(self, body: MjsBody, prefix: str | None = None, suffix: str | None = None) -> MjsBody:
+        ...
+    def set_frame(self, arg0: MjsFrame) -> None:
+        ...
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def frame(self) -> MjsFrame:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def parent(self) -> MjsBody:
+        ...
+    @property
+    def pos(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def quat(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"]:
+        ...
+    @quat.setter
+    def quat(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"]) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+class MjsGeom:
+    alt: MjsOrientation
+    classname: MjsDefault
+    hfieldname: str
+    info: str
+    material: str
+    meshname: str
+    name: str
+    plugin: MjsPlugin
+    def set_frame(self, arg0: MjsFrame) -> None:
+        ...
+    @property
+    def adhesion(self) -> float:
+        ...
+    @adhesion.setter
+    def adhesion(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def conaffinity(self) -> int:
+        ...
+    @conaffinity.setter
+    def conaffinity(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def condim(self) -> int:
+        ...
+    @condim.setter
+    def condim(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def contype(self) -> int:
+        ...
+    @contype.setter
+    def contype(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def density(self) -> float:
+        ...
+    @density.setter
+    def density(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def fitscale(self) -> float:
+        ...
+    @fitscale.setter
+    def fitscale(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def fluid_coefs(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]", "flags.writeable"]:
+        ...
+    @fluid_coefs.setter
+    def fluid_coefs(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]"]) -> None:
+        ...
+    @property
+    def fluid_ellipsoid(self) -> float:
+        ...
+    @fluid_ellipsoid.setter
+    def fluid_ellipsoid(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def frame(self) -> MjsFrame:
+        ...
+    @property
+    def friction(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @friction.setter
+    def friction(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def fromto(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]", "flags.writeable"]:
+        ...
+    @fromto.setter
+    def fromto(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]"]) -> None:
+        ...
+    @property
+    def gap(self) -> float:
+        ...
+    @gap.setter
+    def gap(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def group(self) -> int:
+        ...
+    @group.setter
+    def group(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def margin(self) -> float:
+        ...
+    @margin.setter
+    def margin(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def mass(self) -> float:
+        ...
+    @mass.setter
+    def mass(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def parent(self) -> MjsBody:
+        ...
+    @property
+    def pos(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def priority(self) -> int:
+        ...
+    @priority.setter
+    def priority(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def quat(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"]:
+        ...
+    @quat.setter
+    def quat(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"]) -> None:
+        ...
+    @property
+    def rgba(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @rgba.setter
+    def rgba(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def size(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @size.setter
+    def size(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def solimp(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]", "flags.writeable"]:
+        ...
+    @solimp.setter
+    def solimp(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]"]) -> None:
+        ...
+    @property
+    def solmix(self) -> float:
+        ...
+    @solmix.setter
+    def solmix(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def solref(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @solref.setter
+    def solref(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def surfacevel(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]", "flags.writeable"]:
+        ...
+    @surfacevel.setter
+    def surfacevel(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]"]) -> None:
+        ...
+    @property
+    def type(self) -> mujoco._enums.mjtGeom:
+        ...
+    @type.setter
+    def type(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def typeinertia(self) -> mujoco._enums.mjtGeomInertia:
+        ...
+    @typeinertia.setter
+    def typeinertia(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def userdata(self) -> MjDoubleVec:
+        ...
+    @userdata.setter
+    def userdata(self, arg1: typing.Any) -> None:
+        ...
+class MjsHField:
+    content_type: str
+    file: str
+    info: str
+    name: str
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def ncol(self) -> int:
+        ...
+    @ncol.setter
+    def ncol(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nrow(self) -> int:
+        ...
+    @nrow.setter
+    def nrow(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def size(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"]:
+        ...
+    @size.setter
+    def size(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"]) -> None:
+        ...
+    @property
+    def userdata(self) -> MjFloatVec:
+        ...
+    @userdata.setter
+    def userdata(self, arg1: typing.Any) -> None:
+        ...
+class MjsJoint:
+    actgravcomp: bool
+    classname: MjsDefault
+    info: str
+    name: str
+    def set_frame(self, arg0: MjsFrame) -> None:
+        ...
+    @property
+    def actfrclimited(self) -> mujoco._enums.mjtLimited:
+        ...
+    @actfrclimited.setter
+    def actfrclimited(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def actfrcrange(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @actfrcrange.setter
+    def actfrcrange(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def align(self) -> mujoco._enums.mjtAlignFree:
+        ...
+    @align.setter
+    def align(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def armature(self) -> float:
+        ...
+    @armature.setter
+    def armature(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def axis(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @axis.setter
+    def axis(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def damping(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @damping.setter
+    def damping(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def frame(self) -> MjsFrame:
+        ...
+    @property
+    def frictionloss(self) -> float:
+        ...
+    @frictionloss.setter
+    def frictionloss(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def group(self) -> int:
+        ...
+    @group.setter
+    def group(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def limited(self) -> mujoco._enums.mjtLimited:
+        ...
+    @limited.setter
+    def limited(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def margin(self) -> float:
+        ...
+    @margin.setter
+    def margin(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def parent(self) -> MjsBody:
+        ...
+    @property
+    def pos(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def range(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @range.setter
+    def range(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def ref(self) -> float:
+        ...
+    @ref.setter
+    def ref(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def solimp_friction(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]", "flags.writeable"]:
+        ...
+    @solimp_friction.setter
+    def solimp_friction(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]"]) -> None:
+        ...
+    @property
+    def solimp_limit(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]", "flags.writeable"]:
+        ...
+    @solimp_limit.setter
+    def solimp_limit(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]"]) -> None:
+        ...
+    @property
+    def solref_friction(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @solref_friction.setter
+    def solref_friction(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def solref_limit(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @solref_limit.setter
+    def solref_limit(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def springdamper(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @springdamper.setter
+    def springdamper(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def springref(self) -> float:
+        ...
+    @springref.setter
+    def springref(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def stiffness(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @stiffness.setter
+    def stiffness(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def type(self) -> mujoco._enums.mjtJoint:
+        ...
+    @type.setter
+    def type(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def userdata(self) -> MjDoubleVec:
+        ...
+    @userdata.setter
+    def userdata(self, arg1: typing.Any) -> None:
+        ...
+class MjsKey:
+    info: str
+    name: str
+    @property
+    def act(self) -> MjDoubleVec:
+        ...
+    @act.setter
+    def act(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def ctrl(self) -> MjDoubleVec:
+        ...
+    @ctrl.setter
+    def ctrl(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def mpos(self) -> MjDoubleVec:
+        ...
+    @mpos.setter
+    def mpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mquat(self) -> MjDoubleVec:
+        ...
+    @mquat.setter
+    def mquat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qpos(self) -> MjDoubleVec:
+        ...
+    @qpos.setter
+    def qpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qvel(self) -> MjDoubleVec:
+        ...
+    @qvel.setter
+    def qvel(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def time(self) -> float:
+        ...
+    @time.setter
+    def time(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+class MjsLight:
+    active: bool
+    castshadow: bool
+    classname: MjsDefault
+    info: str
+    name: str
+    targetbody: str
+    texture: str
+    def set_frame(self, arg0: MjsFrame) -> None:
+        ...
+    @property
+    def ambient(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[3, 1]", "flags.writeable"]:
+        ...
+    @ambient.setter
+    def ambient(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[3, 1]"]) -> None:
+        ...
+    @property
+    def attenuation(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[3, 1]", "flags.writeable"]:
+        ...
+    @attenuation.setter
+    def attenuation(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[3, 1]"]) -> None:
+        ...
+    @property
+    def bulbradius(self) -> float:
+        ...
+    @bulbradius.setter
+    def bulbradius(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def cutoff(self) -> float:
+        ...
+    @cutoff.setter
+    def cutoff(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def diffuse(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[3, 1]", "flags.writeable"]:
+        ...
+    @diffuse.setter
+    def diffuse(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[3, 1]"]) -> None:
+        ...
+    @property
+    def dir(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @dir.setter
+    def dir(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def exponent(self) -> float:
+        ...
+    @exponent.setter
+    def exponent(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def frame(self) -> MjsFrame:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def intensity(self) -> float:
+        ...
+    @intensity.setter
+    def intensity(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def mode(self) -> mujoco._enums.mjtCamLight:
+        ...
+    @mode.setter
+    def mode(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def parent(self) -> MjsBody:
+        ...
+    @property
+    def pos(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def range(self) -> float:
+        ...
+    @range.setter
+    def range(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def specular(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[3, 1]", "flags.writeable"]:
+        ...
+    @specular.setter
+    def specular(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[3, 1]"]) -> None:
+        ...
+    @property
+    def type(self) -> mujoco._enums.mjtLightType:
+        ...
+    @type.setter
+    def type(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjsMaterial:
+    classname: MjsDefault
+    info: str
+    name: str
+    texuniform: bool
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def emission(self) -> float:
+        ...
+    @emission.setter
+    def emission(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def metallic(self) -> float:
+        ...
+    @metallic.setter
+    def metallic(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def reflectance(self) -> float:
+        ...
+    @reflectance.setter
+    def reflectance(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def rgba(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @rgba.setter
+    def rgba(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def roughness(self) -> float:
+        ...
+    @roughness.setter
+    def roughness(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def shininess(self) -> float:
+        ...
+    @shininess.setter
+    def shininess(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def specular(self) -> float:
+        ...
+    @specular.setter
+    def specular(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def texrepeat(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[2, 1]", "flags.writeable"]:
+        ...
+    @texrepeat.setter
+    def texrepeat(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[2, 1]"]) -> None:
+        ...
+    @property
+    def textures(self) -> MjStringVec:
+        ...
+    @textures.setter
+    def textures(self, arg1: typing.Any) -> None:
+        ...
+class MjsMesh:
+    classname: MjsDefault
+    content_type: str
+    file: str
+    info: str
+    material: str
+    name: str
+    needsdf: bool
+    plugin: MjsPlugin
+    smoothnormal: bool
+    def make_cone(self, nedge: typing.SupportsInt | typing.SupportsIndex, radius: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    def make_hemisphere(self, resolution: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def make_plate(self, resolution: typing.Annotated[collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex], "FixedSize(2)"] = [0, 0]) -> None:
+        ...
+    def make_sphere(self, subdivision: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def make_supersphere(self, resolution: typing.SupportsInt | typing.SupportsIndex, e: typing.SupportsFloat | typing.SupportsIndex, n: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    def make_supertorus(self, resolution: typing.SupportsInt | typing.SupportsIndex, radius: typing.SupportsFloat | typing.SupportsIndex, s: typing.SupportsFloat | typing.SupportsIndex, t: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    def make_wedge(self, resolution: typing.Annotated[collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex], "FixedSize(2)"] = [0, 0], fov: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex], "FixedSize(2)"] = [0.0, 0.0], gamma: typing.SupportsFloat | typing.SupportsIndex = 0) -> None:
+        ...
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def inertia(self) -> mujoco._enums.mjtMeshInertia:
+        ...
+    @inertia.setter
+    def inertia(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def maxhullvert(self) -> int:
+        ...
+    @maxhullvert.setter
+    def maxhullvert(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def octree_maxdepth(self) -> int:
+        ...
+    @octree_maxdepth.setter
+    def octree_maxdepth(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def refpos(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @refpos.setter
+    def refpos(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def refquat(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"]:
+        ...
+    @refquat.setter
+    def refquat(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"]) -> None:
+        ...
+    @property
+    def scale(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @scale.setter
+    def scale(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def userface(self) -> MjIntVec:
+        ...
+    @userface.setter
+    def userface(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def userfacenormal(self) -> MjIntVec:
+        ...
+    @userfacenormal.setter
+    def userfacenormal(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def userfacetexcoord(self) -> MjIntVec:
+        ...
+    @userfacetexcoord.setter
+    def userfacetexcoord(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def usernormal(self) -> MjFloatVec:
+        ...
+    @usernormal.setter
+    def usernormal(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def usertexcoord(self) -> MjFloatVec:
+        ...
+    @usertexcoord.setter
+    def usertexcoord(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def uservert(self) -> MjFloatVec:
+        ...
+    @uservert.setter
+    def uservert(self, arg1: typing.Any) -> None:
+        ...
+class MjsNumeric:
+    info: str
+    name: str
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def data(self) -> MjDoubleVec:
+        ...
+    @data.setter
+    def data(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def size(self) -> int:
+        ...
+    @size.setter
+    def size(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjsOrientation:
+    @property
+    def axisangle(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"]:
+        ...
+    @axisangle.setter
+    def axisangle(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"]) -> None:
+        ...
+    @property
+    def euler(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @euler.setter
+    def euler(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def type(self) -> mujoco._enums.mjtOrientation:
+        ...
+    @type.setter
+    def type(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def xyaxes(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]", "flags.writeable"]:
+        ...
+    @xyaxes.setter
+    def xyaxes(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]"]) -> None:
+        ...
+    @property
+    def zaxis(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @zaxis.setter
+    def zaxis(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+class MjsPair:
+    classname: MjsDefault
+    geomname1: str
+    geomname2: str
+    info: str
+    name: str
+    @property
+    def adhesion(self) -> float:
+        ...
+    @adhesion.setter
+    def adhesion(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def condim(self) -> int:
+        ...
+    @condim.setter
+    def condim(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def friction(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]", "flags.writeable"]:
+        ...
+    @friction.setter
+    def friction(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]"]) -> None:
+        ...
+    @property
+    def gap(self) -> float:
+        ...
+    @gap.setter
+    def gap(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def margin(self) -> float:
+        ...
+    @margin.setter
+    def margin(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def solimp(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]", "flags.writeable"]:
+        ...
+    @solimp.setter
+    def solimp(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]"]) -> None:
+        ...
+    @property
+    def solref(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @solref.setter
+    def solref(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def solreffriction(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @solreffriction.setter
+    def solreffriction(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+class MjsPlugin:
+    active: bool
+    config: dict
+    info: str
+    name: str
+    plugin_name: str
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @id.setter
+    def id(self, arg1: MjsPlugin) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+class MjsSensor:
+    info: str
+    name: str
+    objname: str
+    plugin: MjsPlugin
+    refname: str
+    def get_data_size(self) -> int:
+        ...
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def cutoff(self) -> float:
+        ...
+    @cutoff.setter
+    def cutoff(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def datatype(self) -> mujoco._enums.mjtDataType:
+        ...
+    @datatype.setter
+    def datatype(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def delay(self) -> float:
+        ...
+    @delay.setter
+    def delay(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def dim(self) -> int:
+        ...
+    @dim.setter
+    def dim(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def interp(self) -> int:
+        ...
+    @interp.setter
+    def interp(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def interval(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @interval.setter
+    def interval(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def intprm(self) -> typing.Annotated[numpy.typing.NDArray[numpy.int32], "[3, 1]", "flags.writeable"]:
+        ...
+    @intprm.setter
+    def intprm(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[3, 1]"]) -> None:
+        ...
+    @property
+    def needstage(self) -> mujoco._enums.mjtStage:
+        ...
+    @needstage.setter
+    def needstage(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def noise(self) -> float:
+        ...
+    @noise.setter
+    def noise(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nsample(self) -> int:
+        ...
+    @nsample.setter
+    def nsample(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def objtype(self) -> mujoco._enums.mjtObj:
+        ...
+    @objtype.setter
+    def objtype(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def reftype(self) -> mujoco._enums.mjtObj:
+        ...
+    @reftype.setter
+    def reftype(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def type(self) -> mujoco._enums.mjtSensor:
+        ...
+    @type.setter
+    def type(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def userdata(self) -> MjDoubleVec:
+        ...
+    @userdata.setter
+    def userdata(self, arg1: typing.Any) -> None:
+        ...
+class MjsSite:
+    alt: MjsOrientation
+    classname: MjsDefault
+    info: str
+    material: str
+    name: str
+    def attach_body(self, body: MjsBody, prefix: str | None = None, suffix: str | None = None) -> MjsBody:
+        ...
+    def set_frame(self, arg0: MjsFrame) -> None:
+        ...
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def frame(self) -> MjsFrame:
+        ...
+    @property
+    def fromto(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]", "flags.writeable"]:
+        ...
+    @fromto.setter
+    def fromto(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]"]) -> None:
+        ...
+    @property
+    def group(self) -> int:
+        ...
+    @group.setter
+    def group(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def parent(self) -> MjsBody:
+        ...
+    @property
+    def pos(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def quat(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]", "flags.writeable"]:
+        ...
+    @quat.setter
+    def quat(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[4, 1]"]) -> None:
+        ...
+    @property
+    def rgba(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @rgba.setter
+    def rgba(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def size(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @size.setter
+    def size(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def type(self) -> mujoco._enums.mjtGeom:
+        ...
+    @type.setter
+    def type(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def userdata(self) -> MjDoubleVec:
+        ...
+    @userdata.setter
+    def userdata(self, arg1: typing.Any) -> None:
+        ...
+class MjsSkin:
+    file: str
+    info: str
+    material: str
+    name: str
+    @property
+    def bindpos(self) -> MjFloatVec:
+        ...
+    @bindpos.setter
+    def bindpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def bindquat(self) -> MjFloatVec:
+        ...
+    @bindquat.setter
+    def bindquat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def bodyname(self) -> MjStringVec:
+        ...
+    @bodyname.setter
+    def bodyname(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def face(self) -> MjIntVec:
+        ...
+    @face.setter
+    def face(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def group(self) -> int:
+        ...
+    @group.setter
+    def group(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def inflate(self) -> float:
+        ...
+    @inflate.setter
+    def inflate(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def rgba(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @rgba.setter
+    def rgba(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def texcoord(self) -> MjFloatVec:
+        ...
+    @texcoord.setter
+    def texcoord(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def vert(self) -> MjFloatVec:
+        ...
+    @vert.setter
+    def vert(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def vertid(self) -> list:
+        ...
+    @vertid.setter
+    def vertid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def vertweight(self) -> list:
+        ...
+    @vertweight.setter
+    def vertweight(self, arg1: typing.Any) -> None:
+        ...
+class MjsTendon:
+    info: str
+    material: str
+    name: str
+    def default(self) -> MjsDefault:
+        ...
+    def wrap_geom(self, arg0: str, arg1: str) -> MjsWrap:
+        ...
+    def wrap_joint(self, arg0: str, arg1: typing.SupportsFloat | typing.SupportsIndex) -> MjsWrap:
+        ...
+    def wrap_pulley(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> MjsWrap:
+        ...
+    def wrap_site(self, arg0: str) -> MjsWrap:
+        ...
+    @property
+    def actfrclimited(self) -> mujoco._enums.mjtLimited:
+        ...
+    @actfrclimited.setter
+    def actfrclimited(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def actfrcrange(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @actfrcrange.setter
+    def actfrcrange(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def armature(self) -> float:
+        ...
+    @armature.setter
+    def armature(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def damping(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @damping.setter
+    def damping(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def frictionloss(self) -> float:
+        ...
+    @frictionloss.setter
+    def frictionloss(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def group(self) -> int:
+        ...
+    @group.setter
+    def group(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def limited(self) -> mujoco._enums.mjtLimited:
+        ...
+    @limited.setter
+    def limited(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def margin(self) -> float:
+        ...
+    @margin.setter
+    def margin(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def path(self) -> MjsTendonPath:
+        ...
+    @property
+    def range(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @range.setter
+    def range(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def rgba(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]", "flags.writeable"]:
+        ...
+    @rgba.setter
+    def rgba(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, 1]"]) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def solimp_friction(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]", "flags.writeable"]:
+        ...
+    @solimp_friction.setter
+    def solimp_friction(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]"]) -> None:
+        ...
+    @property
+    def solimp_limit(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]", "flags.writeable"]:
+        ...
+    @solimp_limit.setter
+    def solimp_limit(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[5, 1]"]) -> None:
+        ...
+    @property
+    def solref_friction(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @solref_friction.setter
+    def solref_friction(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def solref_limit(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @solref_limit.setter
+    def solref_limit(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def springlength(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]", "flags.writeable"]:
+        ...
+    @springlength.setter
+    def springlength(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[2, 1]"]) -> None:
+        ...
+    @property
+    def stiffness(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @stiffness.setter
+    def stiffness(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def userdata(self) -> MjDoubleVec:
+        ...
+    @userdata.setter
+    def userdata(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def width(self) -> float:
+        ...
+    @width.setter
+    def width(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+class MjsTendonPath:
+    def __getitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> MjsWrap:
+        ...
+    def __len__(self) -> int:
+        ...
+class MjsText:
+    data: str
+    info: str
+    name: str
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+class MjsTexture:
+    content_type: str
+    data: bytes
+    file: str
+    hflip: bool
+    info: str
+    name: str
+    vflip: bool
+    @property
+    def builtin(self) -> mujoco._enums.mjtBuiltin:
+        ...
+    @builtin.setter
+    def builtin(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def colorspace(self) -> mujoco._enums.mjtColorSpace:
+        ...
+    @colorspace.setter
+    def colorspace(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def cubefiles(self) -> MjStringVec:
+        ...
+    @cubefiles.setter
+    def cubefiles(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def gridlayout(self) -> MjCharVec:
+        ...
+    @gridlayout.setter
+    def gridlayout(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def gridsize(self) -> typing.Annotated[numpy.typing.NDArray[numpy.int32], "[2, 1]", "flags.writeable"]:
+        ...
+    @gridsize.setter
+    def gridsize(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.int32], "[2, 1]"]) -> None:
+        ...
+    @property
+    def height(self) -> int:
+        ...
+    @height.setter
+    def height(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def mark(self) -> mujoco._enums.mjtMark:
+        ...
+    @mark.setter
+    def mark(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def markrgb(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @markrgb.setter
+    def markrgb(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def nchannel(self) -> int:
+        ...
+    @nchannel.setter
+    def nchannel(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def random(self) -> float:
+        ...
+    @random.setter
+    def random(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def rgb1(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @rgb1.setter
+    def rgb1(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def rgb2(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]", "flags.writeable"]:
+        ...
+    @rgb2.setter
+    def rgb2(self, arg1: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def type(self) -> mujoco._enums.mjtTexture:
+        ...
+    @type.setter
+    def type(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def width(self) -> int:
+        ...
+    @width.setter
+    def width(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjsTuple:
+    info: str
+    name: str
+    @property
+    def compiler(self) -> MjsCompiler:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def objname(self) -> MjStringVec:
+        ...
+    @objname.setter
+    def objname(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def objprm(self) -> MjDoubleVec:
+        ...
+    @objprm.setter
+    def objprm(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def objtype(self) -> MjIntVec:
+        ...
+    @objtype.setter
+    def objtype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+class MjsWrap:
+    info: str
+    @property
+    def coef(self) -> typing.Any:
+        ...
+    @property
+    def divisor(self) -> typing.Any:
+        ...
+    @property
+    def sidesite(self) -> MjsSite:
+        ...
+    @property
+    def target(self) -> typing.Any:
+        ...
+    @property
+    def type(self) -> mujoco._enums.mjtWrap:
+        ...
+    @type.setter
+    def type(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
diff --git a/typings/mujoco/_structs.pyi b/typings/mujoco/_structs.pyi
new file mode 100644
index 0000000..9f46777
--- /dev/null
+++ b/typings/mujoco/_structs.pyi
@@ -0,0 +1,8930 @@
+from __future__ import annotations
+import mujoco._enums
+import numpy
+import numpy.typing
+import typing
+__all__: list[str] = ['MjContact', 'MjData', 'MjLROpt', 'MjLogConfig', 'MjLogMessage', 'MjModel', 'MjOption', 'MjPreContact', 'MjSolverStat', 'MjStatistic', 'MjTimerStat', 'MjVisual', 'MjWarningStat', 'MjrRect', 'MjrVertexAttribute', 'MjvCamera', 'MjvFigure', 'MjvGLCamera', 'MjvGeom', 'MjvLight', 'MjvOption', 'MjvPerturb', 'MjvScene', 'mjv_averageCamera']
+class MjContact:
+    __hash__: typing.ClassVar[None] = None
+    def __copy__(self) -> MjContact:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjContact:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def H(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @H.setter
+    def H(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def adhesion(self) -> float:
+        ...
+    @adhesion.setter
+    def adhesion(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def dim(self) -> int:
+        ...
+    @dim.setter
+    def dim(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def dist(self) -> float:
+        ...
+    @dist.setter
+    def dist(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def efc_address(self) -> int:
+        ...
+    @efc_address.setter
+    def efc_address(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def elem(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @elem.setter
+    def elem(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def exclude(self) -> int:
+        ...
+    @exclude.setter
+    def exclude(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def flex(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex.setter
+    def flex(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def frame(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @frame.setter
+    def frame(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def friction(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @friction.setter
+    def friction(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @geom.setter
+    def geom(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom1(self) -> int:
+        ...
+    @geom1.setter
+    def geom1(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def geom2(self) -> int:
+        ...
+    @geom2.setter
+    def geom2(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def includemargin(self) -> float:
+        ...
+    @includemargin.setter
+    def includemargin(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def mu(self) -> float:
+        ...
+    @mu.setter
+    def mu(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def solimp(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @solimp.setter
+    def solimp(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def solref(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @solref.setter
+    def solref(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def solreffriction(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @solreffriction.setter
+    def solreffriction(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def vert(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @vert.setter
+    def vert(self, arg1: typing.Any) -> None:
+        ...
+class MjData:
+    _all_fields: typing.ClassVar[tuple] = ('narena', 'nbuffer', 'nplugin', 'pstack', 'pbase', 'parena', 'threadpool', 'maxuse_stack', 'maxuse_arena', 'maxuse_con', 'maxuse_efc', 'ncon', 'ne', 'nf', 'nl', 'nefc', 'nJ', 'efm_active', 'nefmK', 'nefmdof', 'nefmL', 'nY', 'nA', 'nisland', 'nidof', 'ntree_awake', 'nbody_awake', 'nparent_awake', 'nv_awake', 'flg_energypos', 'flg_energyvel', 'flg_subtreevel', 'flg_rnepost', 'time', 'solver', 'solver_niter', 'solver_nnz', 'solver_fwdinv', 'warning', 'timer', 'energy', 'qpos', 'qvel', 'act', 'history', 'qacc_warmstart', 'plugin_state', 'ctrl', 'qfrc_applied', 'xfrc_applied', 'eq_active', 'mocap_pos', 'mocap_quat', 'qacc', 'act_dot', 'userdata', 'sensordata', 'tree_asleep', 'plugin', 'plugin_data', 'xpos', 'xquat', 'xmat', 'xipos', 'ximat', 'xanchor', 'xaxis', 'geom_xpos', 'geom_xmat', 'site_xpos', 'site_xmat', 'cam_xpos', 'cam_xmat', 'light_xpos', 'light_xdir', 'subtree_com', 'cdof', 'cinert', 'flexvert_xpos', 'flexelem_aabb', 'flexelem_krot', 'flexedge_J', 'flexedge_length', 'flexvert_J', 'flexvert_length', 'bvh_aabb_dyn', 'ten_wrapadr', 'ten_wrapnum', 'ten_J', 'ten_length', 'wrap_obj', 'wrap_xpos', 'actuator_length', 'moment_rownnz', 'moment_rowadr', 'moment_colind', 'actuator_moment', 'crb', 'M', 'qLD', 'qLDiagInv', 'bvh_active', 'tree_awake', 'body_awake', 'body_awake_ind', 'parent_awake_ind', 'dof_awake_ind', 'flexedge_velocity', 'ten_velocity', 'actuator_velocity', 'cvel', 'cdof_dot', 'qfrc_bias', 'qfrc_spring', 'qfrc_damper', 'qfrc_gravcomp', 'qfrc_fluid', 'qfrc_adhesion', 'qfrc_passive', 'subtree_linvel', 'subtree_angmom', 'qH', 'qHDiagInv', 'qDeriv', 'qLU', 'actuator_force', 'qfrc_actuator', 'qfrc_smooth', 'qacc_smooth', 'qfrc_constraint', 'qfrc_inverse', 'cacc', 'cfrc_int', 'cfrc_ext')
+    flg_energypos: bool
+    flg_energyvel: bool
+    flg_rnepost: bool
+    flg_subtreevel: bool
+    @staticmethod
+    def bind(data: MjData, specs: typing.Union[typing.Sequence[typing.Union[mujoco._specs.MjsBody, mujoco._specs.MjsFrame, mujoco._specs.MjsGeom, mujoco._specs.MjsJoint, mujoco._specs.MjsLight, mujoco._specs.MjsMaterial, mujoco._specs.MjsSite, mujoco._specs.MjsMesh, mujoco._specs.MjsSkin, mujoco._specs.MjsTexture, mujoco._specs.MjsText, mujoco._specs.MjsTuple, mujoco._specs.MjsCamera, mujoco._specs.MjsFlex, mujoco._specs.MjsHField, mujoco._specs.MjsKey, mujoco._specs.MjsNumeric, mujoco._specs.MjsPair, mujoco._specs.MjsExclude, mujoco._specs.MjsEquality, mujoco._specs.MjsTendon, mujoco._specs.MjsSensor, mujoco._specs.MjsActuator, mujoco._specs.MjsPlugin]], mujoco._specs.MjsBody, mujoco._specs.MjsFrame, mujoco._specs.MjsGeom, mujoco._specs.MjsJoint, mujoco._specs.MjsLight, mujoco._specs.MjsMaterial, mujoco._specs.MjsSite, mujoco._specs.MjsMesh, mujoco._specs.MjsSkin, mujoco._specs.MjsTexture, mujoco._specs.MjsText, mujoco._specs.MjsTuple, mujoco._specs.MjsCamera, mujoco._specs.MjsFlex, mujoco._specs.MjsHField, mujoco._specs.MjsKey, mujoco._specs.MjsNumeric, mujoco._specs.MjsPair, mujoco._specs.MjsExclude, mujoco._specs.MjsEquality, mujoco._specs.MjsTendon, mujoco._specs.MjsSensor, mujoco._specs.MjsActuator, mujoco._specs.MjsPlugin]):
+        """
+        Bind a Mujoco spec to a mjData.
+        
+        Args:
+          data: The mjData to bind to.
+          specs: The mjSpec elements to use for binding, can be a single element or a
+            sequence.
+        Returns:
+          A MjDataGroupedViews object or a list of the same type.
+        """
+    def __copy__(self) -> MjData:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjData:
+        ...
+    def __getstate__(self) -> bytes:
+        ...
+    def __init__(self, arg0: MjModel) -> None:
+        ...
+    def __setstate__(self, arg0: bytes) -> None:
+        ...
+    @typing.overload
+    def actuator(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def actuator(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsActuator_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsBody_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsCamera_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsGeom_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsJoint_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsLight_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsSensor_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsSite_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsTendon_ = None) -> ...:
+        ...
+    @typing.overload
+    def body(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def body(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def cam(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def cam(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def camera(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def camera(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def geom(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def geom(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def jnt(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def jnt(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def joint(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def joint(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def light(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def light(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def sensor(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def sensor(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def site(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def site(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def ten(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def ten(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def tendon(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def tendon(self, name: str = '') -> ...:
+        ...
+    @property
+    def M(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @M.setter
+    def M(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _address(self) -> int:
+        ...
+    @property
+    def act(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @act.setter
+    def act(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def act_dot(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @act_dot.setter
+    def act_dot(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_force(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_force.setter
+    def actuator_force(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_length(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_length.setter
+    def actuator_length(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_moment(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_moment.setter
+    def actuator_moment(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_velocity(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_velocity.setter
+    def actuator_velocity(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_awake(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_awake.setter
+    def body_awake(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_awake_ind(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_awake_ind.setter
+    def body_awake_ind(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def bvh_aabb_dyn(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @bvh_aabb_dyn.setter
+    def bvh_aabb_dyn(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def bvh_active(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @bvh_active.setter
+    def bvh_active(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cacc(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cacc.setter
+    def cacc(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_xmat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cam_xmat.setter
+    def cam_xmat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_xpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cam_xpos.setter
+    def cam_xpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cdof(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cdof.setter
+    def cdof(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cdof_dot(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cdof_dot.setter
+    def cdof_dot(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cfrc_ext(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cfrc_ext.setter
+    def cfrc_ext(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cfrc_int(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cfrc_int.setter
+    def cfrc_int(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cinert(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cinert.setter
+    def cinert(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def contact(self) -> _MjContactList:
+        ...
+    @property
+    def crb(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @crb.setter
+    def crb(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def ctrl(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @ctrl.setter
+    def ctrl(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cvel(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cvel.setter
+    def cvel(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dof_awake_ind(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @dof_awake_ind.setter
+    def dof_awake_ind(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dof_island(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efc_AR(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efc_AR_colind(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efc_AR_rowadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efc_AR_rownnz(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efc_D(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efc_J(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efc_J_colind(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efc_J_rowadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efc_J_rownnz(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efc_J_rowsuper(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efc_KBIP(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efc_R(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efc_Y(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efc_Y_colind(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efc_Y_rowadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efc_Y_rownnz(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efc_aref(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efc_b(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efc_diagA(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efc_force(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efc_frictionloss(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efc_id(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efc_island(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efc_margin(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efc_pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efc_state(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efc_type(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efc_vel(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efm_K_colind(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efm_K_rowadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efm_K_rownnz(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efm_K_val(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efm_L(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efm_L_colind(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efm_L_rowadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efm_L_rownnz(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def efm_active(self) -> int:
+        ...
+    @efm_active.setter
+    def efm_active(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def efm_c(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efm_dofid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def energy(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @energy.setter
+    def energy(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def eq_active(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @eq_active.setter
+    def eq_active(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexedge_J(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flexedge_J.setter
+    def flexedge_J(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexedge_length(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flexedge_length.setter
+    def flexedge_length(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexedge_velocity(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flexedge_velocity.setter
+    def flexedge_velocity(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexelem_aabb(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flexelem_aabb.setter
+    def flexelem_aabb(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexelem_krot(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flexelem_krot.setter
+    def flexelem_krot(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexvert_J(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flexvert_J.setter
+    def flexvert_J(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexvert_length(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flexvert_length.setter
+    def flexvert_length(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexvert_xpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flexvert_xpos.setter
+    def flexvert_xpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_xmat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @geom_xmat.setter
+    def geom_xmat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_xpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @geom_xpos.setter
+    def geom_xpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def history(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @history.setter
+    def history(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def iacc(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def iacc_smooth(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def iefc_D(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def iefc_R(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def iefc_aref(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def iefc_force(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def iefc_frictionloss(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def iefc_id(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def iefc_state(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def iefc_type(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def ifrc_constraint(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def ifrc_smooth(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def island_dofadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def island_idofadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def island_iefcadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def island_itreeadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def island_ne(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def island_nefc(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def island_nf(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def island_ntree(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def island_nv(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def light_xdir(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @light_xdir.setter
+    def light_xdir(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_xpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @light_xpos.setter
+    def light_xpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def map_dof2idof(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def map_efc2iefc(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def map_idof2dof(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def map_iefc2efc(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def map_itree2tree(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def maxuse_arena(self) -> int:
+        ...
+    @maxuse_arena.setter
+    def maxuse_arena(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def maxuse_con(self) -> int:
+        ...
+    @maxuse_con.setter
+    def maxuse_con(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def maxuse_efc(self) -> int:
+        ...
+    @maxuse_efc.setter
+    def maxuse_efc(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def maxuse_stack(self) -> int:
+        ...
+    @maxuse_stack.setter
+    def maxuse_stack(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def mocap_pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @mocap_pos.setter
+    def mocap_pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mocap_quat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @mocap_quat.setter
+    def mocap_quat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def model(self) -> MjModel:
+        ...
+    @property
+    def moment_colind(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @moment_colind.setter
+    def moment_colind(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def moment_rowadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @moment_rowadr.setter
+    def moment_rowadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def moment_rownnz(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @moment_rownnz.setter
+    def moment_rownnz(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def nA(self) -> int:
+        ...
+    @nA.setter
+    def nA(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nJ(self) -> int:
+        ...
+    @nJ.setter
+    def nJ(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nY(self) -> int:
+        ...
+    @nY.setter
+    def nY(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def narena(self) -> int:
+        ...
+    @narena.setter
+    def narena(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nbody_awake(self) -> int:
+        ...
+    @nbody_awake.setter
+    def nbody_awake(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nbuffer(self) -> int:
+        ...
+    @nbuffer.setter
+    def nbuffer(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def ncon(self) -> int:
+        ...
+    @ncon.setter
+    def ncon(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def ne(self) -> int:
+        ...
+    @ne.setter
+    def ne(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nefc(self) -> int:
+        ...
+    @nefc.setter
+    def nefc(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nefmK(self) -> int:
+        ...
+    @nefmK.setter
+    def nefmK(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nefmL(self) -> int:
+        ...
+    @nefmL.setter
+    def nefmL(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nefmdof(self) -> int:
+        ...
+    @nefmdof.setter
+    def nefmdof(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nf(self) -> int:
+        ...
+    @nf.setter
+    def nf(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nidof(self) -> int:
+        ...
+    @nidof.setter
+    def nidof(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nisland(self) -> int:
+        ...
+    @nisland.setter
+    def nisland(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nl(self) -> int:
+        ...
+    @nl.setter
+    def nl(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nparent_awake(self) -> int:
+        ...
+    @nparent_awake.setter
+    def nparent_awake(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nplugin(self) -> int:
+        ...
+    @nplugin.setter
+    def nplugin(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def ntree_awake(self) -> int:
+        ...
+    @ntree_awake.setter
+    def ntree_awake(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nv_awake(self) -> int:
+        ...
+    @nv_awake.setter
+    def nv_awake(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def parena(self) -> int:
+        ...
+    @parena.setter
+    def parena(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def parent_awake_ind(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @parent_awake_ind.setter
+    def parent_awake_ind(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def pbase(self) -> int:
+        ...
+    @pbase.setter
+    def pbase(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def plugin(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @plugin.setter
+    def plugin(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def plugin_data(self) -> numpy.typing.NDArray[numpy.uint64]:
+        ...
+    @plugin_data.setter
+    def plugin_data(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def plugin_state(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @plugin_state.setter
+    def plugin_state(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def pstack(self) -> int:
+        ...
+    @pstack.setter
+    def pstack(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def qDeriv(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qDeriv.setter
+    def qDeriv(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qH(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qH.setter
+    def qH(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qHDiagInv(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qHDiagInv.setter
+    def qHDiagInv(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qLD(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qLD.setter
+    def qLD(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qLDiagInv(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qLDiagInv.setter
+    def qLDiagInv(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qLU(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qLU.setter
+    def qLU(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qacc(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qacc.setter
+    def qacc(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qacc_smooth(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qacc_smooth.setter
+    def qacc_smooth(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qacc_warmstart(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qacc_warmstart.setter
+    def qacc_warmstart(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_actuator(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_actuator.setter
+    def qfrc_actuator(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_adhesion(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_adhesion.setter
+    def qfrc_adhesion(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_applied(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_applied.setter
+    def qfrc_applied(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_bias(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_bias.setter
+    def qfrc_bias(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_constraint(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_constraint.setter
+    def qfrc_constraint(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_damper(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_damper.setter
+    def qfrc_damper(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_fluid(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_fluid.setter
+    def qfrc_fluid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_gravcomp(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_gravcomp.setter
+    def qfrc_gravcomp(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_inverse(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_inverse.setter
+    def qfrc_inverse(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_passive(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_passive.setter
+    def qfrc_passive(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_smooth(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_smooth.setter
+    def qfrc_smooth(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_spring(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_spring.setter
+    def qfrc_spring(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qpos.setter
+    def qpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qvel(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qvel.setter
+    def qvel(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensordata(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @sensordata.setter
+    def sensordata(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def site_xmat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @site_xmat.setter
+    def site_xmat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def site_xpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @site_xpos.setter
+    def site_xpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def solver(self) -> _MjSolverStatList:
+        ...
+    @property
+    def solver_fwdinv(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @solver_fwdinv.setter
+    def solver_fwdinv(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def solver_niter(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @solver_niter.setter
+    def solver_niter(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def solver_nnz(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @solver_nnz.setter
+    def solver_nnz(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def subtree_angmom(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @subtree_angmom.setter
+    def subtree_angmom(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def subtree_com(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @subtree_com.setter
+    def subtree_com(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def subtree_linvel(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @subtree_linvel.setter
+    def subtree_linvel(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def ten_J(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @ten_J.setter
+    def ten_J(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def ten_length(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @ten_length.setter
+    def ten_length(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def ten_velocity(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @ten_velocity.setter
+    def ten_velocity(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def ten_wrapadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @ten_wrapadr.setter
+    def ten_wrapadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def ten_wrapnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @ten_wrapnum.setter
+    def ten_wrapnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_efcadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def threadpool(self) -> int:
+        ...
+    @threadpool.setter
+    def threadpool(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def time(self) -> float:
+        ...
+    @time.setter
+    def time(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def timer(self) -> _MjTimerStatList:
+        ...
+    @property
+    def tree_asleep(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tree_asleep.setter
+    def tree_asleep(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tree_awake(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tree_awake.setter
+    def tree_awake(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tree_island(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def userdata(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @userdata.setter
+    def userdata(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def warning(self) -> _MjWarningStatList:
+        ...
+    @property
+    def wrap_obj(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @wrap_obj.setter
+    def wrap_obj(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def wrap_xpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @wrap_xpos.setter
+    def wrap_xpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xanchor(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xanchor.setter
+    def xanchor(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xaxis(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xaxis.setter
+    def xaxis(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xfrc_applied(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xfrc_applied.setter
+    def xfrc_applied(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def ximat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @ximat.setter
+    def ximat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xipos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xipos.setter
+    def xipos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xmat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xmat.setter
+    def xmat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xpos.setter
+    def xpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xquat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xquat.setter
+    def xquat(self, arg1: typing.Any) -> None:
+        ...
+class MjLROpt:
+    __hash__: typing.ClassVar[None] = None
+    def __copy__(self) -> MjLROpt:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjLROpt:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def accel(self) -> float:
+        ...
+    @accel.setter
+    def accel(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def interval(self) -> float:
+        ...
+    @interval.setter
+    def interval(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def inttotal(self) -> float:
+        ...
+    @inttotal.setter
+    def inttotal(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def maxforce(self) -> float:
+        ...
+    @maxforce.setter
+    def maxforce(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def mode(self) -> int:
+        ...
+    @mode.setter
+    def mode(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def timeconst(self) -> float:
+        ...
+    @timeconst.setter
+    def timeconst(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def timestep(self) -> float:
+        ...
+    @timestep.setter
+    def timestep(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def tolrange(self) -> float:
+        ...
+    @tolrange.setter
+    def tolrange(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def useexisting(self) -> int:
+        ...
+    @useexisting.setter
+    def useexisting(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def uselimit(self) -> int:
+        ...
+    @uselimit.setter
+    def uselimit(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjLogConfig:
+    __hash__: typing.ClassVar[None] = None
+    logfile: str
+    logto_console: bool
+    logto_file: bool
+    @staticmethod
+    def get() -> MjLogConfig:
+        ...
+    def __copy__(self) -> MjLogConfig:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjLogConfig:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def set(self) -> None:
+        ...
+    @property
+    def topics(self) -> int:
+        ...
+    @topics.setter
+    def topics(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjLogMessage:
+    __hash__: typing.ClassVar[None] = None
+    subject: str
+    timestamp: bool
+    def __copy__(self) -> MjLogMessage:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjLogMessage:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def body(self) -> typing.Any:
+        ...
+    @property
+    def file(self) -> typing.Any:
+        ...
+    @property
+    def func(self) -> typing.Any:
+        ...
+    @property
+    def level(self) -> int:
+        ...
+    @level.setter
+    def level(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def line(self) -> int:
+        ...
+    @line.setter
+    def line(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def topic(self) -> int:
+        ...
+    @topic.setter
+    def topic(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjModel:
+    _all_fields: typing.ClassVar[tuple] = ('nq', 'nv', 'nu', 'nactuator', 'nout', 'na', 'nbody', 'nbvh', 'nbvhstatic', 'nbvhdynamic', 'noct', 'njnt', 'ntree', 'nM', 'nB', 'nC', 'nD', 'ngeom', 'nsite', 'ncam', 'nlight', 'nflex', 'nflexnode', 'nflexvert', 'nflexedge', 'nflexelem', 'nflexelemdata', 'nflexstiffness', 'nflexbending', 'nefm0dof', 'nefm0L', 'nflexelemedge', 'nflexshelldata', 'nflexevpair', 'nflextexcoord', 'nJfe', 'nJfv', 'nmesh', 'nmeshvert', 'nmeshnormal', 'nmeshtexcoord', 'nmeshface', 'nmeshgraph', 'nmeshpoly', 'nmeshpolyvert', 'nmeshpolymap', 'nskin', 'nskinvert', 'nskintexvert', 'nskinface', 'nskinbone', 'nskinbonevert', 'nhfield', 'nhfielddata', 'ntex', 'ntexdata', 'nmat', 'npair', 'nexclude', 'neq', 'ntendon', 'nJten', 'nwrap', 'nsensor', 'nnumeric', 'nnumericdata', 'ntext', 'ntextdata', 'ntuple', 'ntupledata', 'nkey', 'nmocap', 'nplugin', 'npluginattr', 'nuser_body', 'nuser_jnt', 'nuser_geom', 'nuser_site', 'nuser_cam', 'nuser_tendon', 'nuser_actuator', 'nuser_sensor', 'nnames', 'npaths', 'nnames_map', 'nJmom', 'ngravcomp', 'nemax', 'njmax', 'nconmax', 'npolygonmax', 'nmeshdegmax', 'nuserdata', 'nsensordata', 'npluginstate', 'nhistory', 'narena', 'nbuffer', 'qpos0', 'qpos_spring', 'body_parentid', 'body_rootid', 'body_weldid', 'body_mocapid', 'body_jntnum', 'body_jntadr', 'body_dofnum', 'body_dofadr', 'body_treeid', 'body_geomnum', 'body_geomadr', 'body_simple', 'body_sameframe', 'body_pos', 'body_quat', 'body_ipos', 'body_iquat', 'body_mass', 'body_subtreemass', 'body_inertia', 'body_invweight0', 'body_gravcomp', 'body_margin', 'body_user', 'body_plugin', 'body_contype', 'body_conaffinity', 'body_bvhadr', 'body_bvhnum', 'bvh_depth', 'bvh_child', 'bvh_nodeid', 'bvh_aabb', 'oct_depth', 'oct_child', 'oct_aabb', 'oct_coeff', 'jnt_type', 'jnt_qposadr', 'jnt_dofadr', 'jnt_bodyid', 'jnt_actuatorid', 'jnt_group', 'jnt_limited', 'jnt_actfrclimited', 'jnt_actgravcomp', 'jnt_solref', 'jnt_solimp', 'jnt_pos', 'jnt_axis', 'jnt_stiffness', 'jnt_stiffnesspoly', 'jnt_range', 'jnt_actfrcrange', 'jnt_margin', 'jnt_user', 'dof_bodyid', 'dof_jntid', 'dof_parentid', 'dof_treeid', 'dof_Madr', 'dof_simplenum', 'dof_solref', 'dof_solimp', 'dof_frictionloss', 'dof_armature', 'dof_damping', 'dof_dampingpoly', 'dof_invweight0', 'dof_M0', 'dof_length', 'tree_bodyadr', 'tree_bodynum', 'tree_dofadr', 'tree_dofnum', 'tree_sleep_policy', 'geom_type', 'geom_contype', 'geom_conaffinity', 'geom_condim', 'geom_bodyid', 'geom_dataid', 'geom_matid', 'geom_group', 'geom_priority', 'geom_plugin', 'geom_sameframe', 'geom_solmix', 'geom_solref', 'geom_solimp', 'geom_size', 'geom_aabb', 'geom_rbound', 'geom_pos', 'geom_quat', 'geom_friction', 'geom_margin', 'geom_gap', 'geom_surfacevel', 'geom_adhesion', 'geom_fluid', 'geom_user', 'geom_rgba', 'site_type', 'site_bodyid', 'site_matid', 'site_group', 'site_sameframe', 'site_size', 'site_pos', 'site_quat', 'site_user', 'site_rgba', 'cam_mode', 'cam_bodyid', 'cam_targetbodyid', 'cam_pos', 'cam_quat', 'cam_poscom0', 'cam_pos0', 'cam_mat0', 'cam_projection', 'cam_fovy', 'cam_ipd', 'cam_resolution', 'cam_output', 'cam_sensorsize', 'cam_intrinsic', 'cam_user', 'light_mode', 'light_bodyid', 'light_targetbodyid', 'light_type', 'light_texid', 'light_castshadow', 'light_bulbradius', 'light_intensity', 'light_range', 'light_active', 'light_pos', 'light_dir', 'light_poscom0', 'light_pos0', 'light_dir0', 'light_attenuation', 'light_cutoff', 'light_exponent', 'light_ambient', 'light_diffuse', 'light_specular', 'flex_contype', 'flex_conaffinity', 'flex_condim', 'flex_priority', 'flex_solmix', 'flex_solref', 'flex_solimp', 'flex_friction', 'flex_margin', 'flex_gap', 'flex_internal', 'flex_selfcollide', 'flex_activelayers', 'flex_passive', 'flex_dim', 'flex_matid', 'flex_group', 'flex_interp', 'flex_cellnum', 'flex_nodeadr', 'flex_nodenum', 'flex_vertadr', 'flex_vertnum', 'flex_edgeadr', 'flex_edgenum', 'flex_elemadr', 'flex_elemnum', 'flex_elemdataadr', 'flex_stiffnessadr', 'flex_elemedgeadr', 'flex_bendingadr', 'flex_shellnum', 'flex_shelldataadr', 'flex_evpairadr', 'flex_evpairnum', 'flex_texcoordadr', 'flex_nodebodyid', 'flex_vertbodyid', 'flex_vertedgeadr', 'flex_vertedgenum', 'flex_vertedge', 'flex_edge', 'flex_edgeflap', 'flex_elem', 'flex_elemtexcoord', 'flex_elemedge', 'flex_elemlayer', 'flex_shell', 'flex_evpair', 'flex_vert', 'flex_vert0', 'flex_vertmetric', 'flex_node', 'flex_node0', 'flexedge_length0', 'flexedge_invweight0', 'flex_radius', 'flex_size', 'flex_stiffness', 'flex_bending', 'efm0_dofid', 'efm0_L_rownnz', 'efm0_L_rowadr', 'efm0_L_colind', 'efm0_L', 'flex_damping', 'flex_edgestiffness', 'flex_edgedamping', 'flex_edgeequality', 'flex_rigid', 'flexedge_rigid', 'flex_centered', 'flex_flatskin', 'flex_bvhadr', 'flex_bvhnum', 'flexedge_J_rownnz', 'flexedge_J_rowadr', 'flexedge_J_colind', 'flexvert_J_rownnz', 'flexvert_J_rowadr', 'flexvert_J_colind', 'flex_rgba', 'flex_texcoord', 'mesh_vertadr', 'mesh_vertnum', 'mesh_faceadr', 'mesh_facenum', 'mesh_bvhadr', 'mesh_bvhnum', 'mesh_octadr', 'mesh_octnum', 'mesh_normaladr', 'mesh_normalnum', 'mesh_texcoordadr', 'mesh_texcoordnum', 'mesh_graphadr', 'mesh_vert', 'mesh_normal', 'mesh_texcoord', 'mesh_face', 'mesh_facenormal', 'mesh_facetexcoord', 'mesh_graph', 'mesh_scale', 'mesh_pos', 'mesh_quat', 'mesh_pathadr', 'mesh_polynum', 'mesh_polyadr', 'mesh_polynormal', 'mesh_polyvertadr', 'mesh_polyvertnum', 'mesh_polyvert', 'mesh_polymapadr', 'mesh_polymapnum', 'mesh_polymap', 'skin_matid', 'skin_group', 'skin_rgba', 'skin_inflate', 'skin_vertadr', 'skin_vertnum', 'skin_texcoordadr', 'skin_faceadr', 'skin_facenum', 'skin_boneadr', 'skin_bonenum', 'skin_vert', 'skin_texcoord', 'skin_face', 'skin_bonevertadr', 'skin_bonevertnum', 'skin_bonebindpos', 'skin_bonebindquat', 'skin_bonebodyid', 'skin_bonevertid', 'skin_bonevertweight', 'skin_pathadr', 'hfield_size', 'hfield_nrow', 'hfield_ncol', 'hfield_adr', 'hfield_data', 'hfield_pathadr', 'tex_type', 'tex_colorspace', 'tex_height', 'tex_width', 'tex_nchannel', 'tex_adr', 'tex_data', 'tex_pathadr', 'mat_texid', 'mat_texuniform', 'mat_texrepeat', 'mat_emission', 'mat_specular', 'mat_shininess', 'mat_reflectance', 'mat_metallic', 'mat_roughness', 'mat_rgba', 'pair_dim', 'pair_geom1', 'pair_geom2', 'pair_signature', 'pair_solref', 'pair_solreffriction', 'pair_solimp', 'pair_margin', 'pair_gap', 'pair_adhesion', 'pair_friction', 'exclude_signature', 'eq_type', 'eq_obj1id', 'eq_obj2id', 'eq_objtype', 'eq_active0', 'eq_solref', 'eq_solimp', 'eq_data', 'tendon_adr', 'tendon_num', 'tendon_matid', 'tendon_actuatorid', 'tendon_group', 'tendon_treenum', 'tendon_treeid', 'ten_J_rownnz', 'ten_J_rowadr', 'ten_J_colind', 'tendon_limited', 'tendon_actfrclimited', 'tendon_width', 'tendon_solref_lim', 'tendon_solimp_lim', 'tendon_solref_fri', 'tendon_solimp_fri', 'tendon_range', 'tendon_actfrcrange', 'tendon_margin', 'tendon_stiffness', 'tendon_stiffnesspoly', 'tendon_damping', 'tendon_dampingpoly', 'tendon_armature', 'tendon_frictionloss', 'tendon_lengthspring', 'tendon_length0', 'tendon_invweight0', 'tendon_user', 'tendon_rgba', 'wrap_type', 'wrap_objid', 'wrap_prm', 'actuator_trntype', 'actuator_dyntype', 'actuator_gaintype', 'actuator_biastype', 'actuator_ctrladr', 'actuator_ctrlnum', 'actuator_ctrlspec', 'actuator_outadr', 'actuator_outnum', 'actuator_actadr', 'actuator_actnum', 'actuator_trnid', 'actuator_cranklength', 'actuator_dynprm', 'actuator_gainprm', 'actuator_biasprm', 'actuator_actlimited', 'actuator_actrange', 'actuator_actearly', 'actuator_history', 'actuator_historyadr', 'actuator_delay', 'actuator_damping', 'actuator_dampingpoly', 'actuator_armature', 'actuator_group', 'actuator_user', 'actuator_plugin', 'actuator_forcelimited', 'actuator_forcerange', 'actuator_ctrllimited', 'actuator_ctrlrange', 'actuator_gear', 'actuator_acc0', 'actuator_length0', 'actuator_lengthrange', 'sensor_type', 'sensor_datatype', 'sensor_needstage', 'sensor_objtype', 'sensor_objid', 'sensor_reftype', 'sensor_refid', 'sensor_intprm', 'sensor_dim', 'sensor_adr', 'sensor_cutoff', 'sensor_noise', 'sensor_history', 'sensor_historyadr', 'sensor_delay', 'sensor_interval', 'sensor_user', 'sensor_plugin', 'plugin', 'plugin_stateadr', 'plugin_statenum', 'plugin_attr', 'plugin_attradr', 'numeric_adr', 'numeric_size', 'numeric_data', 'text_adr', 'text_size', 'text_data', 'tuple_adr', 'tuple_size', 'tuple_objtype', 'tuple_objid', 'tuple_objprm', 'key_time', 'key_qpos', 'key_qvel', 'key_act', 'key_mpos', 'key_mquat', 'key_ctrl', 'name_bodyadr', 'name_jntadr', 'name_geomadr', 'name_siteadr', 'name_camadr', 'name_lightadr', 'name_flexadr', 'name_meshadr', 'name_skinadr', 'name_hfieldadr', 'name_texadr', 'name_matadr', 'name_pairadr', 'name_excludeadr', 'name_eqadr', 'name_tendonadr', 'name_actuatoradr', 'name_sensoradr', 'name_numericadr', 'name_textadr', 'name_tupleadr', 'name_keyadr', 'name_pluginadr', 'names', 'names_map', 'paths', 'B_rownnz', 'B_rowadr', 'B_colind', 'M_rownnz', 'M_rowadr', 'M_colind', 'mapM2M', 'D_rownnz', 'D_rowadr', 'D_diag', 'D_colind', 'mapM2D', 'mapD2M')
+    _size_fields: typing.ClassVar[tuple] = ('nq', 'nv', 'nu', 'nactuator', 'nout', 'na', 'nbody', 'nbvh', 'nbvhstatic', 'nbvhdynamic', 'noct', 'njnt', 'ntree', 'nM', 'nB', 'nC', 'nD', 'ngeom', 'nsite', 'ncam', 'nlight', 'nflex', 'nflexnode', 'nflexvert', 'nflexedge', 'nflexelem', 'nflexelemdata', 'nflexstiffness', 'nflexbending', 'nefm0dof', 'nefm0L', 'nflexelemedge', 'nflexshelldata', 'nflexevpair', 'nflextexcoord', 'nJfe', 'nJfv', 'nmesh', 'nmeshvert', 'nmeshnormal', 'nmeshtexcoord', 'nmeshface', 'nmeshgraph', 'nmeshpoly', 'nmeshpolyvert', 'nmeshpolymap', 'nskin', 'nskinvert', 'nskintexvert', 'nskinface', 'nskinbone', 'nskinbonevert', 'nhfield', 'nhfielddata', 'ntex', 'ntexdata', 'nmat', 'npair', 'nexclude', 'neq', 'ntendon', 'nJten', 'nwrap', 'nsensor', 'nnumeric', 'nnumericdata', 'ntext', 'ntextdata', 'ntuple', 'ntupledata', 'nkey', 'nmocap', 'nplugin', 'npluginattr', 'nuser_body', 'nuser_jnt', 'nuser_geom', 'nuser_site', 'nuser_cam', 'nuser_tendon', 'nuser_actuator', 'nuser_sensor', 'nnames', 'npaths', 'nnames_map', 'nJmom', 'ngravcomp', 'nemax', 'njmax', 'nconmax', 'npolygonmax', 'nmeshdegmax', 'nuserdata', 'nsensordata', 'npluginstate', 'nhistory', 'narena', 'nbuffer')
+    flg_adhesion: bool
+    flg_gravcomp: bool
+    flg_surfacevel: bool
+    @staticmethod
+    def _from_model_ptr(arg0: typing.SupportsInt | typing.SupportsIndex) -> MjModel:
+        ...
+    @staticmethod
+    def bind(model: MjModel, specs: typing.Union[typing.Sequence[typing.Union[mujoco._specs.MjsBody, mujoco._specs.MjsFrame, mujoco._specs.MjsGeom, mujoco._specs.MjsJoint, mujoco._specs.MjsLight, mujoco._specs.MjsMaterial, mujoco._specs.MjsSite, mujoco._specs.MjsMesh, mujoco._specs.MjsSkin, mujoco._specs.MjsTexture, mujoco._specs.MjsText, mujoco._specs.MjsTuple, mujoco._specs.MjsCamera, mujoco._specs.MjsFlex, mujoco._specs.MjsHField, mujoco._specs.MjsKey, mujoco._specs.MjsNumeric, mujoco._specs.MjsPair, mujoco._specs.MjsExclude, mujoco._specs.MjsEquality, mujoco._specs.MjsTendon, mujoco._specs.MjsSensor, mujoco._specs.MjsActuator, mujoco._specs.MjsPlugin]], mujoco._specs.MjsBody, mujoco._specs.MjsFrame, mujoco._specs.MjsGeom, mujoco._specs.MjsJoint, mujoco._specs.MjsLight, mujoco._specs.MjsMaterial, mujoco._specs.MjsSite, mujoco._specs.MjsMesh, mujoco._specs.MjsSkin, mujoco._specs.MjsTexture, mujoco._specs.MjsText, mujoco._specs.MjsTuple, mujoco._specs.MjsCamera, mujoco._specs.MjsFlex, mujoco._specs.MjsHField, mujoco._specs.MjsKey, mujoco._specs.MjsNumeric, mujoco._specs.MjsPair, mujoco._specs.MjsExclude, mujoco._specs.MjsEquality, mujoco._specs.MjsTendon, mujoco._specs.MjsSensor, mujoco._specs.MjsActuator, mujoco._specs.MjsPlugin]):
+        """
+        Bind a Mujoco spec to a mjModel.
+        
+        Args:
+          model: The mjModel to bind to.
+          specs: The mjSpec elements to use for binding, can be a single element or a
+            sequence.
+        Returns:
+          A MjModelGroupedViews object or a list of the same type.
+        """
+    @staticmethod
+    def from_binary_path(filename: str, assets: collections.abc.Mapping[str, bytes] | None = None, vfs: ... = None) -> MjModel:
+        """
+        Loads an MjModel from an MJB file and an optional assets dictionary.
+        
+        The filename for the MJB can also refer to a key in the assets dictionary.
+        This is useful for example when the MJB is not available as a file on disk.
+        """
+    @staticmethod
+    def from_xml_path(filename: str, assets: collections.abc.Mapping[str, bytes] | None = None, vfs: ... = None) -> MjModel:
+        """
+        Loads an MjModel from an XML file and optional assets dict or VFS.
+        """
+    @staticmethod
+    def from_xml_string(xml: str, assets: collections.abc.Mapping[str, bytes] | None = None, vfs: ... = None) -> MjModel:
+        """
+        Loads an MjModel from an XML string and optional assets dict or VFS.
+        """
+    def __copy__(self) -> MjModel:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjModel:
+        ...
+    def __getstate__(self) -> bytes:
+        ...
+    def __setstate__(self, arg0: bytes) -> None:
+        ...
+    @typing.overload
+    def actuator(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def actuator(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsActuator_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsBody_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsCamera_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsEquality_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsExclude_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsGeom_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsHField_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsJoint_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsLight_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsMaterial_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsMesh_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsNumeric_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsPair_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsSensor_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsSite_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsSkin_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsTendon_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsTexture_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsTuple_ = None) -> ...:
+        ...
+    @typing.overload
+    def bind_scalar(self, spec: mjsKey_ = None) -> ...:
+        ...
+    @typing.overload
+    def body(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def body(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def cam(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def cam(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def camera(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def camera(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def eq(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def eq(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def equality(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def equality(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def exclude(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def exclude(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def geom(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def geom(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def hfield(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def hfield(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def jnt(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def jnt(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def joint(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def joint(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def key(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def key(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def keyframe(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def keyframe(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def light(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def light(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def mat(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def mat(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def material(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def material(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def mesh(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def mesh(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def numeric(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def numeric(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def pair(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def pair(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def sensor(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def sensor(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def site(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def site(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def skin(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def skin(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def tendon(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def tendon(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def tex(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def tex(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def texture(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def texture(self, name: str = '') -> ...:
+        ...
+    @typing.overload
+    def tuple(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> ...:
+        ...
+    @typing.overload
+    def tuple(self, name: str = '') -> ...:
+        ...
+    @property
+    def B_colind(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @B_colind.setter
+    def B_colind(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def B_rowadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @B_rowadr.setter
+    def B_rowadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def B_rownnz(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @B_rownnz.setter
+    def B_rownnz(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def D_colind(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @D_colind.setter
+    def D_colind(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def D_diag(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @D_diag.setter
+    def D_diag(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def D_rowadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @D_rowadr.setter
+    def D_rowadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def D_rownnz(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @D_rownnz.setter
+    def D_rownnz(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def M_colind(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @M_colind.setter
+    def M_colind(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def M_rowadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @M_rowadr.setter
+    def M_rowadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def M_rownnz(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @M_rownnz.setter
+    def M_rownnz(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _address(self) -> int:
+        ...
+    @property
+    def _sizes(self) -> numpy.typing.NDArray[numpy.int64]:
+        ...
+    @property
+    def actuator_acc0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_acc0.setter
+    def actuator_acc0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_actadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actuator_actadr.setter
+    def actuator_actadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_actearly(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @actuator_actearly.setter
+    def actuator_actearly(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_actlimited(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @actuator_actlimited.setter
+    def actuator_actlimited(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_actnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actuator_actnum.setter
+    def actuator_actnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_actrange(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_actrange.setter
+    def actuator_actrange(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_armature(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_armature.setter
+    def actuator_armature(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_biasprm(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_biasprm.setter
+    def actuator_biasprm(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_biastype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actuator_biastype.setter
+    def actuator_biastype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_cranklength(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_cranklength.setter
+    def actuator_cranklength(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_ctrladr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actuator_ctrladr.setter
+    def actuator_ctrladr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_ctrllimited(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @actuator_ctrllimited.setter
+    def actuator_ctrllimited(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_ctrlnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actuator_ctrlnum.setter
+    def actuator_ctrlnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_ctrlrange(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_ctrlrange.setter
+    def actuator_ctrlrange(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_ctrlspec(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actuator_ctrlspec.setter
+    def actuator_ctrlspec(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_damping(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_damping.setter
+    def actuator_damping(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_dampingpoly(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_dampingpoly.setter
+    def actuator_dampingpoly(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_delay(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_delay.setter
+    def actuator_delay(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_dynprm(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_dynprm.setter
+    def actuator_dynprm(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_dyntype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actuator_dyntype.setter
+    def actuator_dyntype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_forcelimited(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @actuator_forcelimited.setter
+    def actuator_forcelimited(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_forcerange(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_forcerange.setter
+    def actuator_forcerange(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_gainprm(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_gainprm.setter
+    def actuator_gainprm(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_gaintype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actuator_gaintype.setter
+    def actuator_gaintype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_gear(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_gear.setter
+    def actuator_gear(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_group(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actuator_group.setter
+    def actuator_group(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_history(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actuator_history.setter
+    def actuator_history(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_historyadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actuator_historyadr.setter
+    def actuator_historyadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_length0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_length0.setter
+    def actuator_length0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_lengthrange(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_lengthrange.setter
+    def actuator_lengthrange(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_outadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actuator_outadr.setter
+    def actuator_outadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_outnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actuator_outnum.setter
+    def actuator_outnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_plugin(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actuator_plugin.setter
+    def actuator_plugin(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_trnid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actuator_trnid.setter
+    def actuator_trnid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_trntype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actuator_trntype.setter
+    def actuator_trntype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actuator_user(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actuator_user.setter
+    def actuator_user(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_bvhadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_bvhadr.setter
+    def body_bvhadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_bvhnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_bvhnum.setter
+    def body_bvhnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_conaffinity(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_conaffinity.setter
+    def body_conaffinity(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_contype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_contype.setter
+    def body_contype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_dofadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_dofadr.setter
+    def body_dofadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_dofnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_dofnum.setter
+    def body_dofnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_geomadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_geomadr.setter
+    def body_geomadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_geomnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_geomnum.setter
+    def body_geomnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_gravcomp(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @body_gravcomp.setter
+    def body_gravcomp(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_inertia(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @body_inertia.setter
+    def body_inertia(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_invweight0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @body_invweight0.setter
+    def body_invweight0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_ipos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @body_ipos.setter
+    def body_ipos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_iquat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @body_iquat.setter
+    def body_iquat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_jntadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_jntadr.setter
+    def body_jntadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_jntnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_jntnum.setter
+    def body_jntnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_margin(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @body_margin.setter
+    def body_margin(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_mass(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @body_mass.setter
+    def body_mass(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_mocapid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_mocapid.setter
+    def body_mocapid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_parentid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_parentid.setter
+    def body_parentid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_plugin(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_plugin.setter
+    def body_plugin(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @body_pos.setter
+    def body_pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_quat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @body_quat.setter
+    def body_quat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_rootid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_rootid.setter
+    def body_rootid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_sameframe(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @body_sameframe.setter
+    def body_sameframe(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_simple(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @body_simple.setter
+    def body_simple(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_subtreemass(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @body_subtreemass.setter
+    def body_subtreemass(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_treeid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_treeid.setter
+    def body_treeid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_user(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @body_user.setter
+    def body_user(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def body_weldid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @body_weldid.setter
+    def body_weldid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def bvh_aabb(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @bvh_aabb.setter
+    def bvh_aabb(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def bvh_child(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @bvh_child.setter
+    def bvh_child(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def bvh_depth(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @bvh_depth.setter
+    def bvh_depth(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def bvh_nodeid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @bvh_nodeid.setter
+    def bvh_nodeid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_bodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @cam_bodyid.setter
+    def cam_bodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_fovy(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cam_fovy.setter
+    def cam_fovy(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_intrinsic(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @cam_intrinsic.setter
+    def cam_intrinsic(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_ipd(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cam_ipd.setter
+    def cam_ipd(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_mat0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cam_mat0.setter
+    def cam_mat0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_mode(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @cam_mode.setter
+    def cam_mode(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_output(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @cam_output.setter
+    def cam_output(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cam_pos.setter
+    def cam_pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_pos0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cam_pos0.setter
+    def cam_pos0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_poscom0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cam_poscom0.setter
+    def cam_poscom0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_projection(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @cam_projection.setter
+    def cam_projection(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_quat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cam_quat.setter
+    def cam_quat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_resolution(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @cam_resolution.setter
+    def cam_resolution(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_sensorsize(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @cam_sensorsize.setter
+    def cam_sensorsize(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_targetbodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @cam_targetbodyid.setter
+    def cam_targetbodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cam_user(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cam_user.setter
+    def cam_user(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dof_M0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @dof_M0.setter
+    def dof_M0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dof_Madr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @dof_Madr.setter
+    def dof_Madr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dof_armature(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @dof_armature.setter
+    def dof_armature(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dof_bodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @dof_bodyid.setter
+    def dof_bodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dof_damping(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @dof_damping.setter
+    def dof_damping(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dof_dampingpoly(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @dof_dampingpoly.setter
+    def dof_dampingpoly(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dof_frictionloss(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @dof_frictionloss.setter
+    def dof_frictionloss(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dof_invweight0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @dof_invweight0.setter
+    def dof_invweight0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dof_jntid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @dof_jntid.setter
+    def dof_jntid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dof_length(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @dof_length.setter
+    def dof_length(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dof_parentid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @dof_parentid.setter
+    def dof_parentid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dof_simplenum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @dof_simplenum.setter
+    def dof_simplenum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dof_solimp(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @dof_solimp.setter
+    def dof_solimp(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dof_solref(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @dof_solref.setter
+    def dof_solref(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dof_treeid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @dof_treeid.setter
+    def dof_treeid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def efm0_L(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @efm0_L.setter
+    def efm0_L(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def efm0_L_colind(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @efm0_L_colind.setter
+    def efm0_L_colind(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def efm0_L_rowadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @efm0_L_rowadr.setter
+    def efm0_L_rowadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def efm0_L_rownnz(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @efm0_L_rownnz.setter
+    def efm0_L_rownnz(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def efm0_dofid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @efm0_dofid.setter
+    def efm0_dofid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def eq_active0(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @eq_active0.setter
+    def eq_active0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def eq_data(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @eq_data.setter
+    def eq_data(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def eq_obj1id(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @eq_obj1id.setter
+    def eq_obj1id(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def eq_obj2id(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @eq_obj2id.setter
+    def eq_obj2id(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def eq_objtype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @eq_objtype.setter
+    def eq_objtype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def eq_solimp(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @eq_solimp.setter
+    def eq_solimp(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def eq_solref(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @eq_solref.setter
+    def eq_solref(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def eq_type(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @eq_type.setter
+    def eq_type(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def exclude_signature(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @exclude_signature.setter
+    def exclude_signature(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_activelayers(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_activelayers.setter
+    def flex_activelayers(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_bending(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_bending.setter
+    def flex_bending(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_bendingadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_bendingadr.setter
+    def flex_bendingadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_bvhadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_bvhadr.setter
+    def flex_bvhadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_bvhnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_bvhnum.setter
+    def flex_bvhnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_cellnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_cellnum.setter
+    def flex_cellnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_centered(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @flex_centered.setter
+    def flex_centered(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_conaffinity(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_conaffinity.setter
+    def flex_conaffinity(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_condim(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_condim.setter
+    def flex_condim(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_contype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_contype.setter
+    def flex_contype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_damping(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_damping.setter
+    def flex_damping(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_dim(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_dim.setter
+    def flex_dim(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_edge(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_edge.setter
+    def flex_edge(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_edgeadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_edgeadr.setter
+    def flex_edgeadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_edgedamping(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_edgedamping.setter
+    def flex_edgedamping(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_edgeequality(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_edgeequality.setter
+    def flex_edgeequality(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_edgeflap(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_edgeflap.setter
+    def flex_edgeflap(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_edgenum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_edgenum.setter
+    def flex_edgenum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_edgestiffness(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_edgestiffness.setter
+    def flex_edgestiffness(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_elem(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_elem.setter
+    def flex_elem(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_elemadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_elemadr.setter
+    def flex_elemadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_elemdataadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_elemdataadr.setter
+    def flex_elemdataadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_elemedge(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_elemedge.setter
+    def flex_elemedge(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_elemedgeadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_elemedgeadr.setter
+    def flex_elemedgeadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_elemlayer(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_elemlayer.setter
+    def flex_elemlayer(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_elemnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_elemnum.setter
+    def flex_elemnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_elemtexcoord(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_elemtexcoord.setter
+    def flex_elemtexcoord(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_evpair(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_evpair.setter
+    def flex_evpair(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_evpairadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_evpairadr.setter
+    def flex_evpairadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_evpairnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_evpairnum.setter
+    def flex_evpairnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_flatskin(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @flex_flatskin.setter
+    def flex_flatskin(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_friction(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_friction.setter
+    def flex_friction(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_gap(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_gap.setter
+    def flex_gap(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_group(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_group.setter
+    def flex_group(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_internal(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @flex_internal.setter
+    def flex_internal(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_interp(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_interp.setter
+    def flex_interp(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_margin(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_margin.setter
+    def flex_margin(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_matid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_matid.setter
+    def flex_matid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_node(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_node.setter
+    def flex_node(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_node0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_node0.setter
+    def flex_node0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_nodeadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_nodeadr.setter
+    def flex_nodeadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_nodebodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_nodebodyid.setter
+    def flex_nodebodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_nodenum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_nodenum.setter
+    def flex_nodenum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_passive(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_passive.setter
+    def flex_passive(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_priority(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_priority.setter
+    def flex_priority(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_radius(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_radius.setter
+    def flex_radius(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_rgba(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @flex_rgba.setter
+    def flex_rgba(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_rigid(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @flex_rigid.setter
+    def flex_rigid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_selfcollide(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_selfcollide.setter
+    def flex_selfcollide(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_shell(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_shell.setter
+    def flex_shell(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_shelldataadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_shelldataadr.setter
+    def flex_shelldataadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_shellnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_shellnum.setter
+    def flex_shellnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_size(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_size.setter
+    def flex_size(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_solimp(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_solimp.setter
+    def flex_solimp(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_solmix(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_solmix.setter
+    def flex_solmix(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_solref(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_solref.setter
+    def flex_solref(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_stiffness(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_stiffness.setter
+    def flex_stiffness(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_stiffnessadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_stiffnessadr.setter
+    def flex_stiffnessadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_texcoord(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @flex_texcoord.setter
+    def flex_texcoord(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_texcoordadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_texcoordadr.setter
+    def flex_texcoordadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_vert(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_vert.setter
+    def flex_vert(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_vert0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_vert0.setter
+    def flex_vert0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_vertadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_vertadr.setter
+    def flex_vertadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_vertbodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_vertbodyid.setter
+    def flex_vertbodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_vertedge(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_vertedge.setter
+    def flex_vertedge(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_vertedgeadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_vertedgeadr.setter
+    def flex_vertedgeadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_vertedgenum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_vertedgenum.setter
+    def flex_vertedgenum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_vertmetric(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flex_vertmetric.setter
+    def flex_vertmetric(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_vertnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flex_vertnum.setter
+    def flex_vertnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexedge_J_colind(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flexedge_J_colind.setter
+    def flexedge_J_colind(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexedge_J_rowadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flexedge_J_rowadr.setter
+    def flexedge_J_rowadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexedge_J_rownnz(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flexedge_J_rownnz.setter
+    def flexedge_J_rownnz(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexedge_invweight0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flexedge_invweight0.setter
+    def flexedge_invweight0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexedge_length0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @flexedge_length0.setter
+    def flexedge_length0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexedge_rigid(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @flexedge_rigid.setter
+    def flexedge_rigid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexvert_J_colind(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flexvert_J_colind.setter
+    def flexvert_J_colind(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexvert_J_rowadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flexvert_J_rowadr.setter
+    def flexvert_J_rowadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexvert_J_rownnz(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flexvert_J_rownnz.setter
+    def flexvert_J_rownnz(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_aabb(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @geom_aabb.setter
+    def geom_aabb(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_adhesion(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @geom_adhesion.setter
+    def geom_adhesion(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_bodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @geom_bodyid.setter
+    def geom_bodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_conaffinity(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @geom_conaffinity.setter
+    def geom_conaffinity(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_condim(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @geom_condim.setter
+    def geom_condim(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_contype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @geom_contype.setter
+    def geom_contype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_dataid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @geom_dataid.setter
+    def geom_dataid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_fluid(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @geom_fluid.setter
+    def geom_fluid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_friction(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @geom_friction.setter
+    def geom_friction(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_gap(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @geom_gap.setter
+    def geom_gap(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_group(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @geom_group.setter
+    def geom_group(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_margin(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @geom_margin.setter
+    def geom_margin(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_matid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @geom_matid.setter
+    def geom_matid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_plugin(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @geom_plugin.setter
+    def geom_plugin(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @geom_pos.setter
+    def geom_pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_priority(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @geom_priority.setter
+    def geom_priority(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_quat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @geom_quat.setter
+    def geom_quat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_rbound(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @geom_rbound.setter
+    def geom_rbound(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_rgba(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @geom_rgba.setter
+    def geom_rgba(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_sameframe(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @geom_sameframe.setter
+    def geom_sameframe(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_size(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @geom_size.setter
+    def geom_size(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_solimp(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @geom_solimp.setter
+    def geom_solimp(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_solmix(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @geom_solmix.setter
+    def geom_solmix(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_solref(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @geom_solref.setter
+    def geom_solref(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_surfacevel(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @geom_surfacevel.setter
+    def geom_surfacevel(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_type(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @geom_type.setter
+    def geom_type(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom_user(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @geom_user.setter
+    def geom_user(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def hfield_adr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @hfield_adr.setter
+    def hfield_adr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def hfield_data(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @hfield_data.setter
+    def hfield_data(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def hfield_ncol(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @hfield_ncol.setter
+    def hfield_ncol(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def hfield_nrow(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @hfield_nrow.setter
+    def hfield_nrow(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def hfield_pathadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @hfield_pathadr.setter
+    def hfield_pathadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def hfield_size(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @hfield_size.setter
+    def hfield_size(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_actfrclimited(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @jnt_actfrclimited.setter
+    def jnt_actfrclimited(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_actfrcrange(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @jnt_actfrcrange.setter
+    def jnt_actfrcrange(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_actgravcomp(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @jnt_actgravcomp.setter
+    def jnt_actgravcomp(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_actuatorid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @jnt_actuatorid.setter
+    def jnt_actuatorid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_axis(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @jnt_axis.setter
+    def jnt_axis(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_bodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @jnt_bodyid.setter
+    def jnt_bodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_dofadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @jnt_dofadr.setter
+    def jnt_dofadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_group(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @jnt_group.setter
+    def jnt_group(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_limited(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @jnt_limited.setter
+    def jnt_limited(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_margin(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @jnt_margin.setter
+    def jnt_margin(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @jnt_pos.setter
+    def jnt_pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_qposadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @jnt_qposadr.setter
+    def jnt_qposadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_range(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @jnt_range.setter
+    def jnt_range(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_solimp(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @jnt_solimp.setter
+    def jnt_solimp(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_solref(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @jnt_solref.setter
+    def jnt_solref(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_stiffness(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @jnt_stiffness.setter
+    def jnt_stiffness(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_stiffnesspoly(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @jnt_stiffnesspoly.setter
+    def jnt_stiffnesspoly(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_type(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @jnt_type.setter
+    def jnt_type(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jnt_user(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @jnt_user.setter
+    def jnt_user(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def key_act(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @key_act.setter
+    def key_act(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def key_ctrl(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @key_ctrl.setter
+    def key_ctrl(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def key_mpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @key_mpos.setter
+    def key_mpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def key_mquat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @key_mquat.setter
+    def key_mquat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def key_qpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @key_qpos.setter
+    def key_qpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def key_qvel(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @key_qvel.setter
+    def key_qvel(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def key_time(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @key_time.setter
+    def key_time(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_active(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @light_active.setter
+    def light_active(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_ambient(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @light_ambient.setter
+    def light_ambient(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_attenuation(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @light_attenuation.setter
+    def light_attenuation(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_bodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @light_bodyid.setter
+    def light_bodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_bulbradius(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @light_bulbradius.setter
+    def light_bulbradius(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_castshadow(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @light_castshadow.setter
+    def light_castshadow(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_cutoff(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @light_cutoff.setter
+    def light_cutoff(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_diffuse(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @light_diffuse.setter
+    def light_diffuse(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_dir(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @light_dir.setter
+    def light_dir(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_dir0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @light_dir0.setter
+    def light_dir0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_exponent(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @light_exponent.setter
+    def light_exponent(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_intensity(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @light_intensity.setter
+    def light_intensity(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_mode(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @light_mode.setter
+    def light_mode(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @light_pos.setter
+    def light_pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_pos0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @light_pos0.setter
+    def light_pos0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_poscom0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @light_poscom0.setter
+    def light_poscom0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_range(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @light_range.setter
+    def light_range(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_specular(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @light_specular.setter
+    def light_specular(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_targetbodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @light_targetbodyid.setter
+    def light_targetbodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_texid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @light_texid.setter
+    def light_texid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def light_type(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @light_type.setter
+    def light_type(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mapD2M(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mapD2M.setter
+    def mapD2M(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mapM2D(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mapM2D.setter
+    def mapM2D(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mapM2M(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mapM2M.setter
+    def mapM2M(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mat_emission(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @mat_emission.setter
+    def mat_emission(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mat_metallic(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @mat_metallic.setter
+    def mat_metallic(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mat_reflectance(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @mat_reflectance.setter
+    def mat_reflectance(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mat_rgba(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @mat_rgba.setter
+    def mat_rgba(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mat_roughness(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @mat_roughness.setter
+    def mat_roughness(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mat_shininess(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @mat_shininess.setter
+    def mat_shininess(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mat_specular(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @mat_specular.setter
+    def mat_specular(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mat_texid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mat_texid.setter
+    def mat_texid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mat_texrepeat(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @mat_texrepeat.setter
+    def mat_texrepeat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mat_texuniform(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @mat_texuniform.setter
+    def mat_texuniform(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_bvhadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_bvhadr.setter
+    def mesh_bvhadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_bvhnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_bvhnum.setter
+    def mesh_bvhnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_face(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_face.setter
+    def mesh_face(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_faceadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_faceadr.setter
+    def mesh_faceadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_facenormal(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_facenormal.setter
+    def mesh_facenormal(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_facenum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_facenum.setter
+    def mesh_facenum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_facetexcoord(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_facetexcoord.setter
+    def mesh_facetexcoord(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_graph(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_graph.setter
+    def mesh_graph(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_graphadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_graphadr.setter
+    def mesh_graphadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_normal(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @mesh_normal.setter
+    def mesh_normal(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_normaladr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_normaladr.setter
+    def mesh_normaladr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_normalnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_normalnum.setter
+    def mesh_normalnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_octadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_octadr.setter
+    def mesh_octadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_octnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_octnum.setter
+    def mesh_octnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_pathadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_pathadr.setter
+    def mesh_pathadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_polyadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_polyadr.setter
+    def mesh_polyadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_polymap(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_polymap.setter
+    def mesh_polymap(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_polymapadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_polymapadr.setter
+    def mesh_polymapadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_polymapnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_polymapnum.setter
+    def mesh_polymapnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_polynormal(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @mesh_polynormal.setter
+    def mesh_polynormal(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_polynum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_polynum.setter
+    def mesh_polynum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_polyvert(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_polyvert.setter
+    def mesh_polyvert(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_polyvertadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_polyvertadr.setter
+    def mesh_polyvertadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_polyvertnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_polyvertnum.setter
+    def mesh_polyvertnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @mesh_pos.setter
+    def mesh_pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_quat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @mesh_quat.setter
+    def mesh_quat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_scale(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @mesh_scale.setter
+    def mesh_scale(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_texcoord(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @mesh_texcoord.setter
+    def mesh_texcoord(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_texcoordadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_texcoordadr.setter
+    def mesh_texcoordadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_texcoordnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_texcoordnum.setter
+    def mesh_texcoordnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_vert(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @mesh_vert.setter
+    def mesh_vert(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_vertadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_vertadr.setter
+    def mesh_vertadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mesh_vertnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mesh_vertnum.setter
+    def mesh_vertnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def nB(self) -> int:
+        ...
+    @property
+    def nC(self) -> int:
+        ...
+    @property
+    def nD(self) -> int:
+        ...
+    @property
+    def nJfe(self) -> int:
+        ...
+    @property
+    def nJfv(self) -> int:
+        ...
+    @property
+    def nJmom(self) -> int:
+        ...
+    @property
+    def nJten(self) -> int:
+        ...
+    @property
+    def nM(self) -> int:
+        ...
+    @property
+    def na(self) -> int:
+        ...
+    @property
+    def nactuator(self) -> int:
+        ...
+    @property
+    def name_actuatoradr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_actuatoradr.setter
+    def name_actuatoradr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_bodyadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_bodyadr.setter
+    def name_bodyadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_camadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_camadr.setter
+    def name_camadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_eqadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_eqadr.setter
+    def name_eqadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_excludeadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_excludeadr.setter
+    def name_excludeadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_flexadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_flexadr.setter
+    def name_flexadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_geomadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_geomadr.setter
+    def name_geomadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_hfieldadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_hfieldadr.setter
+    def name_hfieldadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_jntadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_jntadr.setter
+    def name_jntadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_keyadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_keyadr.setter
+    def name_keyadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_lightadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_lightadr.setter
+    def name_lightadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_matadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_matadr.setter
+    def name_matadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_meshadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_meshadr.setter
+    def name_meshadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_numericadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_numericadr.setter
+    def name_numericadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_pairadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_pairadr.setter
+    def name_pairadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_pluginadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_pluginadr.setter
+    def name_pluginadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_sensoradr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_sensoradr.setter
+    def name_sensoradr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_siteadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_siteadr.setter
+    def name_siteadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_skinadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_skinadr.setter
+    def name_skinadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_tendonadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_tendonadr.setter
+    def name_tendonadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_texadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_texadr.setter
+    def name_texadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_textadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_textadr.setter
+    def name_textadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name_tupleadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @name_tupleadr.setter
+    def name_tupleadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def names(self) -> bytes:
+        ...
+    @property
+    def names_map(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @names_map.setter
+    def names_map(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def narena(self) -> int:
+        ...
+    @property
+    def nbody(self) -> int:
+        ...
+    @property
+    def nbuffer(self) -> int:
+        ...
+    @property
+    def nbvh(self) -> int:
+        ...
+    @property
+    def nbvhdynamic(self) -> int:
+        ...
+    @property
+    def nbvhstatic(self) -> int:
+        ...
+    @property
+    def ncam(self) -> int:
+        ...
+    @property
+    def nconmax(self) -> int:
+        ...
+    @property
+    def nefm0L(self) -> int:
+        ...
+    @property
+    def nefm0dof(self) -> int:
+        ...
+    @property
+    def nemax(self) -> int:
+        ...
+    @property
+    def neq(self) -> int:
+        ...
+    @property
+    def nexclude(self) -> int:
+        ...
+    @property
+    def nflex(self) -> int:
+        ...
+    @property
+    def nflexbending(self) -> int:
+        ...
+    @property
+    def nflexedge(self) -> int:
+        ...
+    @property
+    def nflexelem(self) -> int:
+        ...
+    @property
+    def nflexelemdata(self) -> int:
+        ...
+    @property
+    def nflexelemedge(self) -> int:
+        ...
+    @property
+    def nflexevpair(self) -> int:
+        ...
+    @property
+    def nflexnode(self) -> int:
+        ...
+    @property
+    def nflexshelldata(self) -> int:
+        ...
+    @property
+    def nflexstiffness(self) -> int:
+        ...
+    @property
+    def nflextexcoord(self) -> int:
+        ...
+    @property
+    def nflexvert(self) -> int:
+        ...
+    @property
+    def ngeom(self) -> int:
+        ...
+    @property
+    def ngravcomp(self) -> int:
+        ...
+    @property
+    def nhfield(self) -> int:
+        ...
+    @property
+    def nhfielddata(self) -> int:
+        ...
+    @property
+    def nhistory(self) -> int:
+        ...
+    @property
+    def njmax(self) -> int:
+        ...
+    @property
+    def njnt(self) -> int:
+        ...
+    @property
+    def nkey(self) -> int:
+        ...
+    @property
+    def nlight(self) -> int:
+        ...
+    @property
+    def nmat(self) -> int:
+        ...
+    @property
+    def nmesh(self) -> int:
+        ...
+    @property
+    def nmeshdegmax(self) -> int:
+        ...
+    @property
+    def nmeshface(self) -> int:
+        ...
+    @property
+    def nmeshgraph(self) -> int:
+        ...
+    @property
+    def nmeshnormal(self) -> int:
+        ...
+    @property
+    def nmeshpoly(self) -> int:
+        ...
+    @property
+    def nmeshpolymap(self) -> int:
+        ...
+    @property
+    def nmeshpolyvert(self) -> int:
+        ...
+    @property
+    def nmeshtexcoord(self) -> int:
+        ...
+    @property
+    def nmeshvert(self) -> int:
+        ...
+    @property
+    def nmocap(self) -> int:
+        ...
+    @property
+    def nnames(self) -> int:
+        ...
+    @property
+    def nnames_map(self) -> int:
+        ...
+    @property
+    def nnumeric(self) -> int:
+        ...
+    @property
+    def nnumericdata(self) -> int:
+        ...
+    @property
+    def noct(self) -> int:
+        ...
+    @property
+    def nout(self) -> int:
+        ...
+    @property
+    def npair(self) -> int:
+        ...
+    @property
+    def npaths(self) -> int:
+        ...
+    @property
+    def nplugin(self) -> int:
+        ...
+    @property
+    def npluginattr(self) -> int:
+        ...
+    @property
+    def npluginstate(self) -> int:
+        ...
+    @property
+    def npolygonmax(self) -> int:
+        ...
+    @property
+    def nq(self) -> int:
+        ...
+    @property
+    def nsensor(self) -> int:
+        ...
+    @property
+    def nsensordata(self) -> int:
+        ...
+    @property
+    def nsite(self) -> int:
+        ...
+    @property
+    def nskin(self) -> int:
+        ...
+    @property
+    def nskinbone(self) -> int:
+        ...
+    @property
+    def nskinbonevert(self) -> int:
+        ...
+    @property
+    def nskinface(self) -> int:
+        ...
+    @property
+    def nskintexvert(self) -> int:
+        ...
+    @property
+    def nskinvert(self) -> int:
+        ...
+    @property
+    def ntendon(self) -> int:
+        ...
+    @property
+    def ntex(self) -> int:
+        ...
+    @property
+    def ntexdata(self) -> int:
+        ...
+    @property
+    def ntext(self) -> int:
+        ...
+    @property
+    def ntextdata(self) -> int:
+        ...
+    @property
+    def ntree(self) -> int:
+        ...
+    @property
+    def ntuple(self) -> int:
+        ...
+    @property
+    def ntupledata(self) -> int:
+        ...
+    @property
+    def nu(self) -> int:
+        ...
+    @property
+    def numeric_adr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @numeric_adr.setter
+    def numeric_adr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def numeric_data(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @numeric_data.setter
+    def numeric_data(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def numeric_size(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @numeric_size.setter
+    def numeric_size(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def nuser_actuator(self) -> int:
+        ...
+    @property
+    def nuser_body(self) -> int:
+        ...
+    @property
+    def nuser_cam(self) -> int:
+        ...
+    @property
+    def nuser_geom(self) -> int:
+        ...
+    @property
+    def nuser_jnt(self) -> int:
+        ...
+    @property
+    def nuser_sensor(self) -> int:
+        ...
+    @property
+    def nuser_site(self) -> int:
+        ...
+    @property
+    def nuser_tendon(self) -> int:
+        ...
+    @property
+    def nuserdata(self) -> int:
+        ...
+    @property
+    def nv(self) -> int:
+        ...
+    @property
+    def nwrap(self) -> int:
+        ...
+    @property
+    def oct_aabb(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @oct_aabb.setter
+    def oct_aabb(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def oct_child(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @oct_child.setter
+    def oct_child(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def oct_coeff(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @oct_coeff.setter
+    def oct_coeff(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def oct_depth(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @oct_depth.setter
+    def oct_depth(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def opt(self) -> MjOption:
+        ...
+    @property
+    def pair_adhesion(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @pair_adhesion.setter
+    def pair_adhesion(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def pair_dim(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @pair_dim.setter
+    def pair_dim(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def pair_friction(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @pair_friction.setter
+    def pair_friction(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def pair_gap(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @pair_gap.setter
+    def pair_gap(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def pair_geom1(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @pair_geom1.setter
+    def pair_geom1(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def pair_geom2(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @pair_geom2.setter
+    def pair_geom2(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def pair_margin(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @pair_margin.setter
+    def pair_margin(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def pair_signature(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @pair_signature.setter
+    def pair_signature(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def pair_solimp(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @pair_solimp.setter
+    def pair_solimp(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def pair_solref(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @pair_solref.setter
+    def pair_solref(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def pair_solreffriction(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @pair_solreffriction.setter
+    def pair_solreffriction(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def paths(self) -> bytes:
+        ...
+    @property
+    def plugin(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @plugin.setter
+    def plugin(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def plugin_attr(self) -> numpy.typing.NDArray[numpy.int8]:
+        ...
+    @plugin_attr.setter
+    def plugin_attr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def plugin_attradr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @plugin_attradr.setter
+    def plugin_attradr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def plugin_stateadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @plugin_stateadr.setter
+    def plugin_stateadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def plugin_statenum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @plugin_statenum.setter
+    def plugin_statenum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qpos0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qpos0.setter
+    def qpos0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qpos_spring(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qpos_spring.setter
+    def qpos_spring(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_adr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @sensor_adr.setter
+    def sensor_adr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_cutoff(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @sensor_cutoff.setter
+    def sensor_cutoff(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_datatype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @sensor_datatype.setter
+    def sensor_datatype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_delay(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @sensor_delay.setter
+    def sensor_delay(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_dim(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @sensor_dim.setter
+    def sensor_dim(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_history(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @sensor_history.setter
+    def sensor_history(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_historyadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @sensor_historyadr.setter
+    def sensor_historyadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_interval(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @sensor_interval.setter
+    def sensor_interval(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_intprm(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @sensor_intprm.setter
+    def sensor_intprm(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_needstage(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @sensor_needstage.setter
+    def sensor_needstage(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_noise(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @sensor_noise.setter
+    def sensor_noise(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_objid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @sensor_objid.setter
+    def sensor_objid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_objtype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @sensor_objtype.setter
+    def sensor_objtype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_plugin(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @sensor_plugin.setter
+    def sensor_plugin(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_refid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @sensor_refid.setter
+    def sensor_refid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_reftype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @sensor_reftype.setter
+    def sensor_reftype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_type(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @sensor_type.setter
+    def sensor_type(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sensor_user(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @sensor_user.setter
+    def sensor_user(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def signature(self) -> int:
+        ...
+    @property
+    def site_bodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @site_bodyid.setter
+    def site_bodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def site_group(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @site_group.setter
+    def site_group(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def site_matid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @site_matid.setter
+    def site_matid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def site_pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @site_pos.setter
+    def site_pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def site_quat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @site_quat.setter
+    def site_quat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def site_rgba(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @site_rgba.setter
+    def site_rgba(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def site_sameframe(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @site_sameframe.setter
+    def site_sameframe(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def site_size(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @site_size.setter
+    def site_size(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def site_type(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @site_type.setter
+    def site_type(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def site_user(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @site_user.setter
+    def site_user(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_boneadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skin_boneadr.setter
+    def skin_boneadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_bonebindpos(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @skin_bonebindpos.setter
+    def skin_bonebindpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_bonebindquat(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @skin_bonebindquat.setter
+    def skin_bonebindquat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_bonebodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skin_bonebodyid.setter
+    def skin_bonebodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_bonenum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skin_bonenum.setter
+    def skin_bonenum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_bonevertadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skin_bonevertadr.setter
+    def skin_bonevertadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_bonevertid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skin_bonevertid.setter
+    def skin_bonevertid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_bonevertnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skin_bonevertnum.setter
+    def skin_bonevertnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_bonevertweight(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @skin_bonevertweight.setter
+    def skin_bonevertweight(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_face(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skin_face.setter
+    def skin_face(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_faceadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skin_faceadr.setter
+    def skin_faceadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_facenum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skin_facenum.setter
+    def skin_facenum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_group(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skin_group.setter
+    def skin_group(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_inflate(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @skin_inflate.setter
+    def skin_inflate(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_matid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skin_matid.setter
+    def skin_matid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_pathadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skin_pathadr.setter
+    def skin_pathadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_rgba(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @skin_rgba.setter
+    def skin_rgba(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_texcoord(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @skin_texcoord.setter
+    def skin_texcoord(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_texcoordadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skin_texcoordadr.setter
+    def skin_texcoordadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_vert(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @skin_vert.setter
+    def skin_vert(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_vertadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skin_vertadr.setter
+    def skin_vertadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skin_vertnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skin_vertnum.setter
+    def skin_vertnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def stat(self) -> ...:
+        ...
+    @property
+    def ten_J_colind(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @ten_J_colind.setter
+    def ten_J_colind(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def ten_J_rowadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @ten_J_rowadr.setter
+    def ten_J_rowadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def ten_J_rownnz(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @ten_J_rownnz.setter
+    def ten_J_rownnz(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_actfrclimited(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @tendon_actfrclimited.setter
+    def tendon_actfrclimited(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_actfrcrange(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_actfrcrange.setter
+    def tendon_actfrcrange(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_actuatorid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tendon_actuatorid.setter
+    def tendon_actuatorid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_adr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tendon_adr.setter
+    def tendon_adr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_armature(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_armature.setter
+    def tendon_armature(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_damping(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_damping.setter
+    def tendon_damping(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_dampingpoly(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_dampingpoly.setter
+    def tendon_dampingpoly(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_frictionloss(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_frictionloss.setter
+    def tendon_frictionloss(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_group(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tendon_group.setter
+    def tendon_group(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_invweight0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_invweight0.setter
+    def tendon_invweight0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_length0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_length0.setter
+    def tendon_length0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_lengthspring(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_lengthspring.setter
+    def tendon_lengthspring(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_limited(self) -> numpy.typing.NDArray[numpy.bool]:
+        ...
+    @tendon_limited.setter
+    def tendon_limited(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_margin(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_margin.setter
+    def tendon_margin(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_matid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tendon_matid.setter
+    def tendon_matid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_num(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tendon_num.setter
+    def tendon_num(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_range(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_range.setter
+    def tendon_range(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_rgba(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @tendon_rgba.setter
+    def tendon_rgba(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_solimp_fri(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_solimp_fri.setter
+    def tendon_solimp_fri(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_solimp_lim(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_solimp_lim.setter
+    def tendon_solimp_lim(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_solref_fri(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_solref_fri.setter
+    def tendon_solref_fri(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_solref_lim(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_solref_lim.setter
+    def tendon_solref_lim(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_stiffness(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_stiffness.setter
+    def tendon_stiffness(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_stiffnesspoly(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_stiffnesspoly.setter
+    def tendon_stiffnesspoly(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_treeid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tendon_treeid.setter
+    def tendon_treeid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_treenum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tendon_treenum.setter
+    def tendon_treenum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_user(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_user.setter
+    def tendon_user(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendon_width(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tendon_width.setter
+    def tendon_width(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tex_adr(self) -> numpy.typing.NDArray[numpy.int64]:
+        ...
+    @tex_adr.setter
+    def tex_adr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tex_colorspace(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tex_colorspace.setter
+    def tex_colorspace(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tex_data(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @tex_data.setter
+    def tex_data(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tex_height(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tex_height.setter
+    def tex_height(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tex_nchannel(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tex_nchannel.setter
+    def tex_nchannel(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tex_pathadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tex_pathadr.setter
+    def tex_pathadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tex_type(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tex_type.setter
+    def tex_type(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tex_width(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tex_width.setter
+    def tex_width(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def text_adr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @text_adr.setter
+    def text_adr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def text_data(self) -> bytes:
+        ...
+    @property
+    def text_size(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @text_size.setter
+    def text_size(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tree_bodyadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tree_bodyadr.setter
+    def tree_bodyadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tree_bodynum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tree_bodynum.setter
+    def tree_bodynum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tree_dofadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tree_dofadr.setter
+    def tree_dofadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tree_dofnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tree_dofnum.setter
+    def tree_dofnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tree_sleep_policy(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tree_sleep_policy.setter
+    def tree_sleep_policy(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tuple_adr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tuple_adr.setter
+    def tuple_adr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tuple_objid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tuple_objid.setter
+    def tuple_objid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tuple_objprm(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tuple_objprm.setter
+    def tuple_objprm(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tuple_objtype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tuple_objtype.setter
+    def tuple_objtype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tuple_size(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @tuple_size.setter
+    def tuple_size(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def vis(self) -> MjVisual:
+        ...
+    @property
+    def wrap_objid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @wrap_objid.setter
+    def wrap_objid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def wrap_prm(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @wrap_prm.setter
+    def wrap_prm(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def wrap_type(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @wrap_type.setter
+    def wrap_type(self, arg1: typing.Any) -> None:
+        ...
+class MjOption:
+    __hash__: typing.ClassVar[None] = None
+    _all_fields: typing.ClassVar[tuple] = ('timestep', 'impratio', 'tolerance', 'ls_tolerance', 'noslip_tolerance', 'ccd_tolerance', 'sleep_tolerance', 'gravity', 'wind', 'magnetic', 'density', 'viscosity', 'o_margin', 'o_solref', 'o_solimp', 'o_friction', 'integrator', 'cone', 'jacobian', 'solver', 'iterations', 'ls_iterations', 'noslip_iterations', 'ccd_iterations', 'disableflags', 'enableflags', 'disableactuator', 'sdf_initpoints', 'sdf_iterations')
+    _float_fields: typing.ClassVar[tuple] = ('timestep', 'impratio', 'tolerance', 'ls_tolerance', 'noslip_tolerance', 'ccd_tolerance', 'sleep_tolerance', 'density', 'viscosity', 'o_margin')
+    _floatarray_fields: typing.ClassVar[tuple] = ('gravity', 'wind', 'magnetic', 'o_solref', 'o_solimp', 'o_friction')
+    _int_fields: typing.ClassVar[tuple] = ('integrator', 'cone', 'jacobian', 'solver', 'iterations', 'ls_iterations', 'noslip_iterations', 'ccd_iterations', 'disableflags', 'enableflags', 'disableactuator', 'sdf_initpoints', 'sdf_iterations')
+    def __copy__(self) -> MjOption:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjOption:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def ccd_iterations(self) -> int:
+        ...
+    @ccd_iterations.setter
+    def ccd_iterations(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def ccd_tolerance(self) -> float:
+        ...
+    @ccd_tolerance.setter
+    def ccd_tolerance(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def cone(self) -> int:
+        ...
+    @cone.setter
+    def cone(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def density(self) -> float:
+        ...
+    @density.setter
+    def density(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def disableactuator(self) -> int:
+        ...
+    @disableactuator.setter
+    def disableactuator(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def disableflags(self) -> int:
+        ...
+    @disableflags.setter
+    def disableflags(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def enableflags(self) -> int:
+        ...
+    @enableflags.setter
+    def enableflags(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def gravity(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @gravity.setter
+    def gravity(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def impratio(self) -> float:
+        ...
+    @impratio.setter
+    def impratio(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def integrator(self) -> int:
+        ...
+    @integrator.setter
+    def integrator(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def iterations(self) -> int:
+        ...
+    @iterations.setter
+    def iterations(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def jacobian(self) -> int:
+        ...
+    @jacobian.setter
+    def jacobian(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def ls_iterations(self) -> int:
+        ...
+    @ls_iterations.setter
+    def ls_iterations(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def ls_tolerance(self) -> float:
+        ...
+    @ls_tolerance.setter
+    def ls_tolerance(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def magnetic(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @magnetic.setter
+    def magnetic(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def noslip_iterations(self) -> int:
+        ...
+    @noslip_iterations.setter
+    def noslip_iterations(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def noslip_tolerance(self) -> float:
+        ...
+    @noslip_tolerance.setter
+    def noslip_tolerance(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def o_friction(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @o_friction.setter
+    def o_friction(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def o_margin(self) -> float:
+        ...
+    @o_margin.setter
+    def o_margin(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def o_solimp(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @o_solimp.setter
+    def o_solimp(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def o_solref(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @o_solref.setter
+    def o_solref(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sdf_initpoints(self) -> int:
+        ...
+    @sdf_initpoints.setter
+    def sdf_initpoints(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def sdf_iterations(self) -> int:
+        ...
+    @sdf_iterations.setter
+    def sdf_iterations(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def sleep_tolerance(self) -> float:
+        ...
+    @sleep_tolerance.setter
+    def sleep_tolerance(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def solver(self) -> int:
+        ...
+    @solver.setter
+    def solver(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def timestep(self) -> float:
+        ...
+    @timestep.setter
+    def timestep(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def tolerance(self) -> float:
+        ...
+    @tolerance.setter
+    def tolerance(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def viscosity(self) -> float:
+        ...
+    @viscosity.setter
+    def viscosity(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def wind(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @wind.setter
+    def wind(self, arg1: typing.Any) -> None:
+        ...
+class MjPreContact:
+    __hash__: typing.ClassVar[None] = None
+    def __copy__(self) -> MjPreContact:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjPreContact:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def dist(self) -> float:
+        ...
+    @dist.setter
+    def dist(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def normal(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @normal.setter
+    def normal(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tangent(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @tangent.setter
+    def tangent(self, arg1: typing.Any) -> None:
+        ...
+class MjSolverStat:
+    __hash__: typing.ClassVar[None] = None
+    def __copy__(self) -> MjSolverStat:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjSolverStat:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def gradient(self) -> float:
+        ...
+    @gradient.setter
+    def gradient(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def improvement(self) -> float:
+        ...
+    @improvement.setter
+    def improvement(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def lineslope(self) -> float:
+        ...
+    @lineslope.setter
+    def lineslope(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nactive(self) -> int:
+        ...
+    @nactive.setter
+    def nactive(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nchange(self) -> int:
+        ...
+    @nchange.setter
+    def nchange(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def neval(self) -> int:
+        ...
+    @neval.setter
+    def neval(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nupdate(self) -> int:
+        ...
+    @nupdate.setter
+    def nupdate(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjStatistic:
+    __hash__: typing.ClassVar[None] = None
+    def __copy__(self) -> MjStatistic:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjStatistic:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def center(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @center.setter
+    def center(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def extent(self) -> float:
+        ...
+    @extent.setter
+    def extent(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def meaninertia(self) -> float:
+        ...
+    @meaninertia.setter
+    def meaninertia(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def meanmass(self) -> float:
+        ...
+    @meanmass.setter
+    def meanmass(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def meansize(self) -> float:
+        ...
+    @meansize.setter
+    def meansize(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+class MjTimerStat:
+    __hash__: typing.ClassVar[None] = None
+    def __copy__(self) -> MjTimerStat:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjTimerStat:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def duration(self) -> float:
+        ...
+    @duration.setter
+    def duration(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def number(self) -> int:
+        ...
+    @number.setter
+    def number(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjVisual:
+    class Global:
+        __hash__: typing.ClassVar[None] = None
+        def __copy__(self) -> MjVisual.Global:
+            ...
+        def __deepcopy__(self, arg0: dict) -> MjVisual.Global:
+            ...
+        def __eq__(self, arg0: typing.Any) -> bool:
+            ...
+        def __repr__(self) -> str:
+            ...
+        @property
+        def azimuth(self) -> float:
+            ...
+        @azimuth.setter
+        def azimuth(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def bvactive(self) -> int:
+            ...
+        @bvactive.setter
+        def bvactive(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def cameraid(self) -> int:
+            ...
+        @cameraid.setter
+        def cameraid(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def elevation(self) -> float:
+            ...
+        @elevation.setter
+        def elevation(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def ellipsoidinertia(self) -> int:
+            ...
+        @ellipsoidinertia.setter
+        def ellipsoidinertia(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def fovy(self) -> float:
+            ...
+        @fovy.setter
+        def fovy(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def glow(self) -> float:
+            ...
+        @glow.setter
+        def glow(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def ipd(self) -> float:
+            ...
+        @ipd.setter
+        def ipd(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def linewidth(self) -> float:
+            ...
+        @linewidth.setter
+        def linewidth(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def offheight(self) -> int:
+            ...
+        @offheight.setter
+        def offheight(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def offwidth(self) -> int:
+            ...
+        @offwidth.setter
+        def offwidth(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def orthographic(self) -> int:
+            ...
+        @orthographic.setter
+        def orthographic(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def realtime(self) -> float:
+            ...
+        @realtime.setter
+        def realtime(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+    class Headlight:
+        __hash__: typing.ClassVar[None] = None
+        def __copy__(self) -> MjVisual.Headlight:
+            ...
+        def __deepcopy__(self, arg0: dict) -> MjVisual.Headlight:
+            ...
+        def __eq__(self, arg0: typing.Any) -> bool:
+            ...
+        def __repr__(self) -> str:
+            ...
+        @property
+        def active(self) -> int:
+            ...
+        @active.setter
+        def active(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> int:
+            ...
+        @property
+        def ambient(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @ambient.setter
+        def ambient(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def diffuse(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @diffuse.setter
+        def diffuse(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def specular(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @specular.setter
+        def specular(self, arg1: typing.Any) -> None:
+            ...
+    class Map:
+        __hash__: typing.ClassVar[None] = None
+        def __copy__(self) -> MjVisual.Map:
+            ...
+        def __deepcopy__(self, arg0: dict) -> MjVisual.Map:
+            ...
+        def __eq__(self, arg0: typing.Any) -> bool:
+            ...
+        def __repr__(self) -> str:
+            ...
+        @property
+        def actuatortendon(self) -> float:
+            ...
+        @actuatortendon.setter
+        def actuatortendon(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def alpha(self) -> float:
+            ...
+        @alpha.setter
+        def alpha(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def fogend(self) -> float:
+            ...
+        @fogend.setter
+        def fogend(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def fogstart(self) -> float:
+            ...
+        @fogstart.setter
+        def fogstart(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def force(self) -> float:
+            ...
+        @force.setter
+        def force(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def haze(self) -> float:
+            ...
+        @haze.setter
+        def haze(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def shadowclip(self) -> float:
+            ...
+        @shadowclip.setter
+        def shadowclip(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def shadowscale(self) -> float:
+            ...
+        @shadowscale.setter
+        def shadowscale(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def stiffness(self) -> float:
+            ...
+        @stiffness.setter
+        def stiffness(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def stiffnessrot(self) -> float:
+            ...
+        @stiffnessrot.setter
+        def stiffnessrot(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def torque(self) -> float:
+            ...
+        @torque.setter
+        def torque(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def zfar(self) -> float:
+            ...
+        @zfar.setter
+        def zfar(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def znear(self) -> float:
+            ...
+        @znear.setter
+        def znear(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+    class Quality:
+        __hash__: typing.ClassVar[None] = None
+        def __copy__(self) -> MjVisual.Quality:
+            ...
+        def __deepcopy__(self, arg0: dict) -> MjVisual.Quality:
+            ...
+        def __eq__(self, arg0: typing.Any) -> bool:
+            ...
+        def __repr__(self) -> str:
+            ...
+        @property
+        def numquads(self) -> int:
+            ...
+        @numquads.setter
+        def numquads(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def numslices(self) -> int:
+            ...
+        @numslices.setter
+        def numslices(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def numstacks(self) -> int:
+            ...
+        @numstacks.setter
+        def numstacks(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def offsamples(self) -> int:
+            ...
+        @offsamples.setter
+        def offsamples(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def shadowsize(self) -> int:
+            ...
+        @shadowsize.setter
+        def shadowsize(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+            ...
+    class Rgba:
+        __hash__: typing.ClassVar[None] = None
+        def __copy__(self) -> MjVisual.Rgba:
+            ...
+        def __deepcopy__(self, arg0: dict) -> MjVisual.Rgba:
+            ...
+        def __eq__(self, arg0: typing.Any) -> bool:
+            ...
+        def __repr__(self) -> str:
+            ...
+        @property
+        def actuator(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @actuator.setter
+        def actuator(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def actuatornegative(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @actuatornegative.setter
+        def actuatornegative(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def actuatorpositive(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @actuatorpositive.setter
+        def actuatorpositive(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def bv(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @bv.setter
+        def bv(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def bvactive(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @bvactive.setter
+        def bvactive(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def camera(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @camera.setter
+        def camera(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def com(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @com.setter
+        def com(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def connect(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @connect.setter
+        def connect(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def constraint(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @constraint.setter
+        def constraint(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def contactforce(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @contactforce.setter
+        def contactforce(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def contactfriction(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @contactfriction.setter
+        def contactfriction(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def contactgap(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @contactgap.setter
+        def contactgap(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def contactpoint(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @contactpoint.setter
+        def contactpoint(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def contacttorque(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @contacttorque.setter
+        def contacttorque(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def crankbroken(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @crankbroken.setter
+        def crankbroken(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def fog(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @fog.setter
+        def fog(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def force(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @force.setter
+        def force(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def frustum(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @frustum.setter
+        def frustum(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def haze(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @haze.setter
+        def haze(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def inertia(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @inertia.setter
+        def inertia(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def joint(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @joint.setter
+        def joint(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def light(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @light.setter
+        def light(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def rangefinder(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @rangefinder.setter
+        def rangefinder(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def selectpoint(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @selectpoint.setter
+        def selectpoint(self, arg1: typing.Any) -> None:
+            ...
+        @property
+        def slidercrank(self) -> numpy.typing.NDArray[numpy.float32]:
+            ...
+        @slidercrank.setter
+        def slidercrank(self, arg1: typing.Any) -> None:
+            ...
+    class Scale:
+        __hash__: typing.ClassVar[None] = None
+        def __copy__(self) -> MjVisual.Scale:
+            ...
+        def __deepcopy__(self, arg0: dict) -> MjVisual.Scale:
+            ...
+        def __eq__(self, arg0: typing.Any) -> bool:
+            ...
+        def __repr__(self) -> str:
+            ...
+        @property
+        def actuatorlength(self) -> float:
+            ...
+        @actuatorlength.setter
+        def actuatorlength(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def actuatorwidth(self) -> float:
+            ...
+        @actuatorwidth.setter
+        def actuatorwidth(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def camera(self) -> float:
+            ...
+        @camera.setter
+        def camera(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def com(self) -> float:
+            ...
+        @com.setter
+        def com(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def connect(self) -> float:
+            ...
+        @connect.setter
+        def connect(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def constraint(self) -> float:
+            ...
+        @constraint.setter
+        def constraint(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def contactheight(self) -> float:
+            ...
+        @contactheight.setter
+        def contactheight(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def contactwidth(self) -> float:
+            ...
+        @contactwidth.setter
+        def contactwidth(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def forcewidth(self) -> float:
+            ...
+        @forcewidth.setter
+        def forcewidth(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def framelength(self) -> float:
+            ...
+        @framelength.setter
+        def framelength(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def framewidth(self) -> float:
+            ...
+        @framewidth.setter
+        def framewidth(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def frustum(self) -> float:
+            ...
+        @frustum.setter
+        def frustum(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def jointlength(self) -> float:
+            ...
+        @jointlength.setter
+        def jointlength(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def jointwidth(self) -> float:
+            ...
+        @jointwidth.setter
+        def jointwidth(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def light(self) -> float:
+            ...
+        @light.setter
+        def light(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def selectpoint(self) -> float:
+            ...
+        @selectpoint.setter
+        def selectpoint(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+        @property
+        def slidercrank(self) -> float:
+            ...
+        @slidercrank.setter
+        def slidercrank(self, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None:
+            ...
+    __hash__: typing.ClassVar[None] = None
+    def __copy__(self) -> MjVisual:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjVisual:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def global_(self) -> MjVisual.Global:
+        ...
+    @property
+    def headlight(self) -> MjVisual.Headlight:
+        ...
+    @property
+    def map(self) -> MjVisual.Map:
+        ...
+    @property
+    def quality(self) -> MjVisual.Quality:
+        ...
+    @property
+    def rgba(self) -> MjVisual.Rgba:
+        ...
+    @property
+    def scale(self) -> MjVisual.Scale:
+        ...
+class MjWarningStat:
+    __hash__: typing.ClassVar[None] = None
+    def __copy__(self) -> MjWarningStat:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjWarningStat:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def lastinfo(self) -> int:
+        ...
+    @lastinfo.setter
+    def lastinfo(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def number(self) -> int:
+        ...
+    @number.setter
+    def number(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjrRect:
+    __hash__: typing.ClassVar[None] = None
+    def __copy__(self) -> MjrRect:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjrRect:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self, left: typing.SupportsInt | typing.SupportsIndex, bottom: typing.SupportsInt | typing.SupportsIndex, width: typing.SupportsInt | typing.SupportsIndex, height: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def bottom(self) -> int:
+        ...
+    @bottom.setter
+    def bottom(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def height(self) -> int:
+        ...
+    @height.setter
+    def height(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def left(self) -> int:
+        ...
+    @left.setter
+    def left(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def width(self) -> int:
+        ...
+    @width.setter
+    def width(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjrVertexAttribute:
+    __hash__: typing.ClassVar[None] = None
+    def __copy__(self) -> MjrVertexAttribute:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjrVertexAttribute:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self, usage: typing.SupportsInt | typing.SupportsIndex = 0, type: typing.SupportsInt | typing.SupportsIndex = 0) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def type(self) -> int:
+        ...
+    @type.setter
+    def type(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def usage(self) -> int:
+        ...
+    @usage.setter
+    def usage(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjvCamera:
+    __hash__: typing.ClassVar[None] = None
+    def __copy__(self) -> MjvCamera:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjvCamera:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def azimuth(self) -> float:
+        ...
+    @azimuth.setter
+    def azimuth(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def distance(self) -> float:
+        ...
+    @distance.setter
+    def distance(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def elevation(self) -> float:
+        ...
+    @elevation.setter
+    def elevation(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def fixedcamid(self) -> int:
+        ...
+    @fixedcamid.setter
+    def fixedcamid(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def lookat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @lookat.setter
+    def lookat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def orthographic(self) -> int:
+        ...
+    @orthographic.setter
+    def orthographic(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def trackbodyid(self) -> int:
+        ...
+    @trackbodyid.setter
+    def trackbodyid(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def type(self) -> int:
+        ...
+    @type.setter
+    def type(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjvFigure:
+    minwidth: str
+    title: str
+    xformat: str
+    xlabel: str
+    yformat: str
+    def __copy__(self) -> MjvFigure:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjvFigure:
+        ...
+    def __init__(self) -> None:
+        ...
+    @property
+    def figurergba(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @figurergba.setter
+    def figurergba(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flg_barplot(self) -> int:
+        ...
+    @flg_barplot.setter
+    def flg_barplot(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def flg_extend(self) -> int:
+        ...
+    @flg_extend.setter
+    def flg_extend(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def flg_legend(self) -> int:
+        ...
+    @flg_legend.setter
+    def flg_legend(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def flg_selection(self) -> int:
+        ...
+    @flg_selection.setter
+    def flg_selection(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def flg_symmetric(self) -> int:
+        ...
+    @flg_symmetric.setter
+    def flg_symmetric(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def flg_ticklabel(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flg_ticklabel.setter
+    def flg_ticklabel(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def gridrgb(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @gridrgb.setter
+    def gridrgb(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def gridsize(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @gridsize.setter
+    def gridsize(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def gridwidth(self) -> float:
+        ...
+    @gridwidth.setter
+    def gridwidth(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def highlight(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @highlight.setter
+    def highlight(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def highlightid(self) -> int:
+        ...
+    @highlightid.setter
+    def highlightid(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def legendoffset(self) -> int:
+        ...
+    @legendoffset.setter
+    def legendoffset(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def legendrgba(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @legendrgba.setter
+    def legendrgba(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def linedata(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @linedata.setter
+    def linedata(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def linename(self) -> numpy.ndarray:
+        ...
+    @property
+    def linepnt(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @linepnt.setter
+    def linepnt(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def linergb(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @linergb.setter
+    def linergb(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def linewidth(self) -> float:
+        ...
+    @linewidth.setter
+    def linewidth(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def panergba(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @panergba.setter
+    def panergba(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def range(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @range.setter
+    def range(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def selection(self) -> float:
+        ...
+    @selection.setter
+    def selection(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def subplot(self) -> int:
+        ...
+    @subplot.setter
+    def subplot(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def textrgb(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @textrgb.setter
+    def textrgb(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xaxisdata(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @xaxisdata.setter
+    def xaxisdata(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xaxispixel(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @xaxispixel.setter
+    def xaxispixel(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def yaxisdata(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @yaxisdata.setter
+    def yaxisdata(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def yaxispixel(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @yaxispixel.setter
+    def yaxispixel(self, arg1: typing.Any) -> None:
+        ...
+class MjvGLCamera:
+    __hash__: typing.ClassVar[None] = None
+    def __copy__(self) -> MjvGLCamera:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjvGLCamera:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def forward(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @forward.setter
+    def forward(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def frustum_bottom(self) -> float:
+        ...
+    @frustum_bottom.setter
+    def frustum_bottom(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def frustum_center(self) -> float:
+        ...
+    @frustum_center.setter
+    def frustum_center(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def frustum_far(self) -> float:
+        ...
+    @frustum_far.setter
+    def frustum_far(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def frustum_near(self) -> float:
+        ...
+    @frustum_near.setter
+    def frustum_near(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def frustum_top(self) -> float:
+        ...
+    @frustum_top.setter
+    def frustum_top(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def frustum_width(self) -> float:
+        ...
+    @frustum_width.setter
+    def frustum_width(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def orthographic(self) -> int:
+        ...
+    @orthographic.setter
+    def orthographic(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def pos(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def up(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @up.setter
+    def up(self, arg1: typing.Any) -> None:
+        ...
+class MjvGeom:
+    __hash__: typing.ClassVar[None] = None
+    label: str
+    def __copy__(self) -> MjvGeom:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjvGeom:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def camdist(self) -> float:
+        ...
+    @camdist.setter
+    def camdist(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def category(self) -> int:
+        ...
+    @category.setter
+    def category(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def dataid(self) -> int:
+        ...
+    @dataid.setter
+    def dataid(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def emission(self) -> float:
+        ...
+    @emission.setter
+    def emission(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def mat(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @mat.setter
+    def mat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def matid(self) -> int:
+        ...
+    @matid.setter
+    def matid(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def modelrbound(self) -> float:
+        ...
+    @modelrbound.setter
+    def modelrbound(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def objid(self) -> int:
+        ...
+    @objid.setter
+    def objid(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def objtype(self) -> int:
+        ...
+    @objtype.setter
+    def objtype(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def pos(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def reflectance(self) -> float:
+        ...
+    @reflectance.setter
+    def reflectance(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def rgba(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @rgba.setter
+    def rgba(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def segid(self) -> int:
+        ...
+    @segid.setter
+    def segid(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def shininess(self) -> float:
+        ...
+    @shininess.setter
+    def shininess(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def size(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @size.setter
+    def size(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def specular(self) -> float:
+        ...
+    @specular.setter
+    def specular(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def texcoord(self) -> int:
+        ...
+    @texcoord.setter
+    def texcoord(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def texid(self) -> int:
+        ...
+    @texid.setter
+    def texid(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def texrepeat(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @texrepeat.setter
+    def texrepeat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def texuniform(self) -> int:
+        ...
+    @texuniform.setter
+    def texuniform(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def transparent(self) -> int:
+        ...
+    @transparent.setter
+    def transparent(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def type(self) -> int:
+        ...
+    @type.setter
+    def type(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjvLight:
+    __hash__: typing.ClassVar[None] = None
+    def __copy__(self) -> MjvLight:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjvLight:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def ambient(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @ambient.setter
+    def ambient(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def attenuation(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @attenuation.setter
+    def attenuation(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def bulbradius(self) -> float:
+        ...
+    @bulbradius.setter
+    def bulbradius(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def castshadow(self) -> int:
+        ...
+    @castshadow.setter
+    def castshadow(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def cutoff(self) -> float:
+        ...
+    @cutoff.setter
+    def cutoff(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def diffuse(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @diffuse.setter
+    def diffuse(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dir(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @dir.setter
+    def dir(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def exponent(self) -> float:
+        ...
+    @exponent.setter
+    def exponent(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def headlight(self) -> int:
+        ...
+    @headlight.setter
+    def headlight(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @id.setter
+    def id(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def intensity(self) -> float:
+        ...
+    @intensity.setter
+    def intensity(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def pos(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def range(self) -> float:
+        ...
+    @range.setter
+    def range(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def specular(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @specular.setter
+    def specular(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def texid(self) -> int:
+        ...
+    @texid.setter
+    def texid(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def type(self) -> int:
+        ...
+    @type.setter
+    def type(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjvOption:
+    __hash__: typing.ClassVar[None] = None
+    def __copy__(self) -> MjvOption:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjvOption:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def actuatorgroup(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @actuatorgroup.setter
+    def actuatorgroup(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def bvh_depth(self) -> int:
+        ...
+    @bvh_depth.setter
+    def bvh_depth(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def flags(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @flags.setter
+    def flags(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flex_layer(self) -> int:
+        ...
+    @flex_layer.setter
+    def flex_layer(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def flexgroup(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @flexgroup.setter
+    def flexgroup(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def frame(self) -> int:
+        ...
+    @frame.setter
+    def frame(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def geomgroup(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @geomgroup.setter
+    def geomgroup(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jointgroup(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @jointgroup.setter
+    def jointgroup(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def label(self) -> int:
+        ...
+    @label.setter
+    def label(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def sitegroup(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @sitegroup.setter
+    def sitegroup(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skingroup(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @skingroup.setter
+    def skingroup(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def tendongroup(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @tendongroup.setter
+    def tendongroup(self, arg1: typing.Any) -> None:
+        ...
+class MjvPerturb:
+    __hash__: typing.ClassVar[None] = None
+    def __copy__(self) -> MjvPerturb:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjvPerturb:
+        ...
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def active(self) -> int:
+        ...
+    @active.setter
+    def active(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def active2(self) -> int:
+        ...
+    @active2.setter
+    def active2(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def flexselect(self) -> int:
+        ...
+    @flexselect.setter
+    def flexselect(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def localmass(self) -> float:
+        ...
+    @localmass.setter
+    def localmass(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def localpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @localpos.setter
+    def localpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def refpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @refpos.setter
+    def refpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def refquat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @refquat.setter
+    def refquat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def refselpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @refselpos.setter
+    def refselpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def scale(self) -> float:
+        ...
+    @scale.setter
+    def scale(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def select(self) -> int:
+        ...
+    @select.setter
+    def select(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def skinselect(self) -> int:
+        ...
+    @skinselect.setter
+    def skinselect(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+class MjvScene:
+    def __copy__(self) -> MjvScene:
+        ...
+    def __deepcopy__(self, arg0: dict) -> MjvScene:
+        ...
+    @typing.overload
+    def __init__(self) -> None:
+        ...
+    @typing.overload
+    def __init__(self, model: MjModel, maxgeom: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def camera(self) -> tuple:
+        ...
+    @property
+    def enabletransform(self) -> int:
+        ...
+    @enabletransform.setter
+    def enabletransform(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def flags(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @flags.setter
+    def flags(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexedge(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flexedge.setter
+    def flexedge(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexedgeadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flexedgeadr.setter
+    def flexedgeadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexedgenum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flexedgenum.setter
+    def flexedgenum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexedgeopt(self) -> int:
+        ...
+    @flexedgeopt.setter
+    def flexedgeopt(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def flexface(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @flexface.setter
+    def flexface(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexfaceadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flexfaceadr.setter
+    def flexfaceadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexfacenum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flexfacenum.setter
+    def flexfacenum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexfaceopt(self) -> int:
+        ...
+    @flexfaceopt.setter
+    def flexfaceopt(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def flexfaceused(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flexfaceused.setter
+    def flexfaceused(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexnormal(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @flexnormal.setter
+    def flexnormal(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexskinopt(self) -> int:
+        ...
+    @flexskinopt.setter
+    def flexskinopt(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def flextexcoord(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @flextexcoord.setter
+    def flextexcoord(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexvert(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @flexvert.setter
+    def flexvert(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexvertadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flexvertadr.setter
+    def flexvertadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexvertnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @flexvertnum.setter
+    def flexvertnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def flexvertopt(self) -> int:
+        ...
+    @flexvertopt.setter
+    def flexvertopt(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def framergb(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @framergb.setter
+    def framergb(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def framewidth(self) -> int:
+        ...
+    @framewidth.setter
+    def framewidth(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def geomorder(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @geomorder.setter
+    def geomorder(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geoms(self) -> tuple:
+        ...
+    @property
+    def lights(self) -> tuple:
+        ...
+    @property
+    def maxgeom(self) -> int:
+        ...
+    @maxgeom.setter
+    def maxgeom(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nflex(self) -> int:
+        ...
+    @nflex.setter
+    def nflex(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def ngeom(self) -> int:
+        ...
+    @ngeom.setter
+    def ngeom(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nlight(self) -> int:
+        ...
+    @nlight.setter
+    def nlight(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def nskin(self) -> int:
+        ...
+    @nskin.setter
+    def nskin(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def rotate(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @rotate.setter
+    def rotate(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def scale(self) -> float:
+        ...
+    @scale.setter
+    def scale(self, arg1: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def skinfacenum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skinfacenum.setter
+    def skinfacenum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skinnormal(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @skinnormal.setter
+    def skinnormal(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skinvert(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @skinvert.setter
+    def skinvert(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skinvertadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skinvertadr.setter
+    def skinvertadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def skinvertnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @skinvertnum.setter
+    def skinvertnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def status(self) -> int:
+        ...
+    @status.setter
+    def status(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def stereo(self) -> int:
+        ...
+    @stereo.setter
+    def stereo(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None:
+        ...
+    @property
+    def translate(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @translate.setter
+    def translate(self, arg1: typing.Any) -> None:
+        ...
+class _MjContactList:
+    __hash__: typing.ClassVar[None] = None
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __getitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> MjContact:
+        ...
+    @typing.overload
+    def __getitem__(self, arg0: slice) -> _MjContactList:
+        ...
+    def __len__(self) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def H(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def adhesion(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def dim(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def dist(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def efc_address(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def elem(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def exclude(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def flex(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def frame(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def friction(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def geom(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def geom1(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def geom2(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def includemargin(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def mu(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def solimp(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def solref(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def solreffriction(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def vert(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+class _MjDataActuatorViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def ctrl(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @ctrl.setter
+    def ctrl(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def force(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @force.setter
+    def force(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def length(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @length.setter
+    def length(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def moment(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @moment.setter
+    def moment(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def velocity(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @velocity.setter
+    def velocity(self, arg1: typing.Any) -> None:
+        ...
+class _MjDataBodyViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def cacc(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cacc.setter
+    def cacc(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cfrc_ext(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cfrc_ext.setter
+    def cfrc_ext(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cfrc_int(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cfrc_int.setter
+    def cfrc_int(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cinert(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cinert.setter
+    def cinert(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def crb(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @crb.setter
+    def crb(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cvel(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cvel.setter
+    def cvel(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def subtree_angmom(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @subtree_angmom.setter
+    def subtree_angmom(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def subtree_com(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @subtree_com.setter
+    def subtree_com(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def subtree_linvel(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @subtree_linvel.setter
+    def subtree_linvel(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xfrc_applied(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xfrc_applied.setter
+    def xfrc_applied(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def ximat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @ximat.setter
+    def ximat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xipos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xipos.setter
+    def xipos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xmat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xmat.setter
+    def xmat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xpos.setter
+    def xpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xquat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xquat.setter
+    def xquat(self, arg1: typing.Any) -> None:
+        ...
+class _MjDataCameraViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def xmat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xmat.setter
+    def xmat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xpos.setter
+    def xpos(self, arg1: typing.Any) -> None:
+        ...
+class _MjDataGeomViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def xmat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xmat.setter
+    def xmat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xpos.setter
+    def xpos(self, arg1: typing.Any) -> None:
+        ...
+class _MjDataJointViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def cdof(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cdof.setter
+    def cdof(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cdof_dot(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cdof_dot.setter
+    def cdof_dot(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def qLDiagInv(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qLDiagInv.setter
+    def qLDiagInv(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qacc(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qacc.setter
+    def qacc(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qacc_smooth(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qacc_smooth.setter
+    def qacc_smooth(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qacc_warmstart(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qacc_warmstart.setter
+    def qacc_warmstart(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_actuator(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_actuator.setter
+    def qfrc_actuator(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_applied(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_applied.setter
+    def qfrc_applied(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_bias(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_bias.setter
+    def qfrc_bias(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_constraint(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_constraint.setter
+    def qfrc_constraint(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_inverse(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_inverse.setter
+    def qfrc_inverse(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_passive(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_passive.setter
+    def qfrc_passive(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qfrc_smooth(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qfrc_smooth.setter
+    def qfrc_smooth(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qpos.setter
+    def qpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qvel(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qvel.setter
+    def qvel(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xanchor(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xanchor.setter
+    def xanchor(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xaxis(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xaxis.setter
+    def xaxis(self, arg1: typing.Any) -> None:
+        ...
+class _MjDataLightViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def xdir(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xdir.setter
+    def xdir(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xpos.setter
+    def xpos(self, arg1: typing.Any) -> None:
+        ...
+class _MjDataSensorViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def data(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @data.setter
+    def data(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+class _MjDataSiteViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def xmat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xmat.setter
+    def xmat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def xpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @xpos.setter
+    def xpos(self, arg1: typing.Any) -> None:
+        ...
+class _MjDataTendonViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def length(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @length.setter
+    def length(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def velocity(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @velocity.setter
+    def velocity(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def wrapadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @wrapadr.setter
+    def wrapadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def wrapnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @wrapnum.setter
+    def wrapnum(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelActuatorViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def acc0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @acc0.setter
+    def acc0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actadr.setter
+    def actadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actlimited(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @actlimited.setter
+    def actlimited(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @actnum.setter
+    def actnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def actrange(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @actrange.setter
+    def actrange(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def biasprm(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @biasprm.setter
+    def biasprm(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def biastype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @biastype.setter
+    def biastype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cranklength(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cranklength.setter
+    def cranklength(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def ctrllimited(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @ctrllimited.setter
+    def ctrllimited(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def ctrlrange(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @ctrlrange.setter
+    def ctrlrange(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dynprm(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @dynprm.setter
+    def dynprm(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dyntype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @dyntype.setter
+    def dyntype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def forcelimited(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @forcelimited.setter
+    def forcelimited(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def forcerange(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @forcerange.setter
+    def forcerange(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def gainprm(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @gainprm.setter
+    def gainprm(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def gaintype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @gaintype.setter
+    def gaintype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def gear(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @gear.setter
+    def gear(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def group(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @group.setter
+    def group(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def length0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @length0.setter
+    def length0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def lengthrange(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @lengthrange.setter
+    def lengthrange(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def trnid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @trnid.setter
+    def trnid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def trntype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @trntype.setter
+    def trntype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def user(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @user.setter
+    def user(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelBodyViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def dofadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @dofadr.setter
+    def dofadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dofnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @dofnum.setter
+    def dofnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geomadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @geomadr.setter
+    def geomadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geomnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @geomnum.setter
+    def geomnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def inertia(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @inertia.setter
+    def inertia(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def invweight0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @invweight0.setter
+    def invweight0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def ipos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @ipos.setter
+    def ipos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def iquat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @iquat.setter
+    def iquat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jntadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @jntadr.setter
+    def jntadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jntnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @jntnum.setter
+    def jntnum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mass(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @mass.setter
+    def mass(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mocapid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mocapid.setter
+    def mocapid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def parentid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @parentid.setter
+    def parentid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def quat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @quat.setter
+    def quat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def rootid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @rootid.setter
+    def rootid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sameframe(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @sameframe.setter
+    def sameframe(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def simple(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @simple.setter
+    def simple(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def subtreemass(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @subtreemass.setter
+    def subtreemass(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def user(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @user.setter
+    def user(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def weldid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @weldid.setter
+    def weldid(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelCameraViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def bodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @bodyid.setter
+    def bodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def fovy(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @fovy.setter
+    def fovy(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def ipd(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @ipd.setter
+    def ipd(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mat0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @mat0.setter
+    def mat0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mode(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mode.setter
+    def mode(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def pos0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @pos0.setter
+    def pos0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def poscom0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @poscom0.setter
+    def poscom0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def quat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @quat.setter
+    def quat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def targetbodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @targetbodyid.setter
+    def targetbodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def user(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @user.setter
+    def user(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelEqualityViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def active0(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @active0.setter
+    def active0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def data(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @data.setter
+    def data(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def obj1id(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @obj1id.setter
+    def obj1id(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def obj2id(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @obj2id.setter
+    def obj2id(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def solimp(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @solimp.setter
+    def solimp(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def solref(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @solref.setter
+    def solref(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def type(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @type.setter
+    def type(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelExcludeViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def signature(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @signature.setter
+    def signature(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelGeomViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def bodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @bodyid.setter
+    def bodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def conaffinity(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @conaffinity.setter
+    def conaffinity(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def condim(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @condim.setter
+    def condim(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def contype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @contype.setter
+    def contype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dataid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @dataid.setter
+    def dataid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def friction(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @friction.setter
+    def friction(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def gap(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @gap.setter
+    def gap(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def group(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @group.setter
+    def group(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def margin(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @margin.setter
+    def margin(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def matid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @matid.setter
+    def matid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def priority(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @priority.setter
+    def priority(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def quat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @quat.setter
+    def quat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def rbound(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @rbound.setter
+    def rbound(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def rgba(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @rgba.setter
+    def rgba(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sameframe(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @sameframe.setter
+    def sameframe(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def size(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @size.setter
+    def size(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def solimp(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @solimp.setter
+    def solimp(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def solmix(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @solmix.setter
+    def solmix(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def solref(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @solref.setter
+    def solref(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def type(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @type.setter
+    def type(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def user(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @user.setter
+    def user(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelHfieldViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def adr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @adr.setter
+    def adr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def data(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @data.setter
+    def data(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def ncol(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @ncol.setter
+    def ncol(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def nrow(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @nrow.setter
+    def nrow(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def size(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @size.setter
+    def size(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelJointViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def M0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @M0.setter
+    def M0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def Madr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @Madr.setter
+    def Madr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def armature(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @armature.setter
+    def armature(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def axis(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @axis.setter
+    def axis(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def bodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @bodyid.setter
+    def bodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def damping(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @damping.setter
+    def damping(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dampingpoly(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @dampingpoly.setter
+    def dampingpoly(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dofadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @dofadr.setter
+    def dofadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def frictionloss(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @frictionloss.setter
+    def frictionloss(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def group(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @group.setter
+    def group(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def invweight0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @invweight0.setter
+    def invweight0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def jntid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @jntid.setter
+    def jntid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def limited(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @limited.setter
+    def limited(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def margin(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @margin.setter
+    def margin(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def parentid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @parentid.setter
+    def parentid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qpos0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qpos0.setter
+    def qpos0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qpos_spring(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qpos_spring.setter
+    def qpos_spring(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qposadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @qposadr.setter
+    def qposadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def range(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @range.setter
+    def range(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def simplenum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @simplenum.setter
+    def simplenum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def solimp(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @solimp.setter
+    def solimp(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def solref(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @solref.setter
+    def solref(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def stiffness(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @stiffness.setter
+    def stiffness(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def stiffnesspoly(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @stiffnesspoly.setter
+    def stiffnesspoly(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def type(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @type.setter
+    def type(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def user(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @user.setter
+    def user(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelKeyframeViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def act(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @act.setter
+    def act(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def ctrl(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @ctrl.setter
+    def ctrl(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def mpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @mpos.setter
+    def mpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def mquat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @mquat.setter
+    def mquat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def qpos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qpos.setter
+    def qpos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def qvel(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @qvel.setter
+    def qvel(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def time(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @time.setter
+    def time(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelLightViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def active(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @active.setter
+    def active(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def ambient(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @ambient.setter
+    def ambient(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def attenuation(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @attenuation.setter
+    def attenuation(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def bodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @bodyid.setter
+    def bodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def castshadow(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @castshadow.setter
+    def castshadow(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cutoff(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @cutoff.setter
+    def cutoff(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def diffuse(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @diffuse.setter
+    def diffuse(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dir(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @dir.setter
+    def dir(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dir0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @dir0.setter
+    def dir0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def exponent(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @exponent.setter
+    def exponent(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def mode(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @mode.setter
+    def mode(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def pos0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @pos0.setter
+    def pos0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def poscom0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @poscom0.setter
+    def poscom0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def specular(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @specular.setter
+    def specular(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def targetbodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @targetbodyid.setter
+    def targetbodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def type(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @type.setter
+    def type(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelMaterialViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def emission(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @emission.setter
+    def emission(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def reflectance(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @reflectance.setter
+    def reflectance(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def rgba(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @rgba.setter
+    def rgba(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def shininess(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @shininess.setter
+    def shininess(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def specular(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @specular.setter
+    def specular(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def texid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @texid.setter
+    def texid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def texrepeat(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @texrepeat.setter
+    def texrepeat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def texuniform(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @texuniform.setter
+    def texuniform(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelMeshViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def faceadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @faceadr.setter
+    def faceadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def facenum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @facenum.setter
+    def facenum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def graphadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @graphadr.setter
+    def graphadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def texcoordadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @texcoordadr.setter
+    def texcoordadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def vertadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @vertadr.setter
+    def vertadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def vertnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @vertnum.setter
+    def vertnum(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelNumericViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def adr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @adr.setter
+    def adr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def data(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @data.setter
+    def data(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def size(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @size.setter
+    def size(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelPairViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def dim(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @dim.setter
+    def dim(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def friction(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @friction.setter
+    def friction(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def gap(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @gap.setter
+    def gap(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom1(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @geom1.setter
+    def geom1(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def geom2(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @geom2.setter
+    def geom2(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def margin(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @margin.setter
+    def margin(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def signature(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @signature.setter
+    def signature(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def solimp(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @solimp.setter
+    def solimp(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def solref(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @solref.setter
+    def solref(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelSensorViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def adr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @adr.setter
+    def adr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def cutoff(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @cutoff.setter
+    def cutoff(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def datatype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @datatype.setter
+    def datatype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def dim(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @dim.setter
+    def dim(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def needstage(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @needstage.setter
+    def needstage(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def noise(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @noise.setter
+    def noise(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def objid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @objid.setter
+    def objid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def objtype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @objtype.setter
+    def objtype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def refid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @refid.setter
+    def refid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def reftype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @reftype.setter
+    def reftype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def type(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @type.setter
+    def type(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def user(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @user.setter
+    def user(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelSiteViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def bodyid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @bodyid.setter
+    def bodyid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def group(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @group.setter
+    def group(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def matid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @matid.setter
+    def matid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def pos(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @pos.setter
+    def pos(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def quat(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @quat.setter
+    def quat(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def rgba(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @rgba.setter
+    def rgba(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def sameframe(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @sameframe.setter
+    def sameframe(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def size(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @size.setter
+    def size(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def type(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @type.setter
+    def type(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def user(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @user.setter
+    def user(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelSkinViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def boneadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @boneadr.setter
+    def boneadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def bonenum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @bonenum.setter
+    def bonenum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def faceadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @faceadr.setter
+    def faceadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def facenum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @facenum.setter
+    def facenum(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def inflate(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @inflate.setter
+    def inflate(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def matid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @matid.setter
+    def matid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def rgba(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @rgba.setter
+    def rgba(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def texcoordadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @texcoordadr.setter
+    def texcoordadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def vertadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @vertadr.setter
+    def vertadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def vertnum(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @vertnum.setter
+    def vertnum(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelTendonViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def J_colind(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @J_colind.setter
+    def J_colind(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def J_rowadr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @J_rowadr.setter
+    def J_rowadr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def J_rownnz(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @J_rownnz.setter
+    def J_rownnz(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _adr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @_adr.setter
+    def _adr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _damping(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @_damping.setter
+    def _damping(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _dampingpoly(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @_dampingpoly.setter
+    def _dampingpoly(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _frictionloss(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @_frictionloss.setter
+    def _frictionloss(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _group(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @_group.setter
+    def _group(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _invweight0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @_invweight0.setter
+    def _invweight0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _length0(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @_length0.setter
+    def _length0(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _lengthspring(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @_lengthspring.setter
+    def _lengthspring(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _limited(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @_limited.setter
+    def _limited(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _margin(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @_margin.setter
+    def _margin(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _matid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @_matid.setter
+    def _matid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _num(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @_num.setter
+    def _num(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _range(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @_range.setter
+    def _range(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _rgba(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    @_rgba.setter
+    def _rgba(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _solimp_fri(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @_solimp_fri.setter
+    def _solimp_fri(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _solimp_lim(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @_solimp_lim.setter
+    def _solimp_lim(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _solref_fri(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @_solref_fri.setter
+    def _solref_fri(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _solref_lim(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @_solref_lim.setter
+    def _solref_lim(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _stiffness(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @_stiffness.setter
+    def _stiffness(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _stiffnesspoly(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @_stiffnesspoly.setter
+    def _stiffnesspoly(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _user(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @_user.setter
+    def _user(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def _width(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @_width.setter
+    def _width(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+class _MjModelTextureViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def adr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @adr.setter
+    def adr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def data(self) -> numpy.typing.NDArray[numpy.uint8]:
+        ...
+    @data.setter
+    def data(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def height(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @height.setter
+    def height(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def nchannel(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @nchannel.setter
+    def nchannel(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def type(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @type.setter
+    def type(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def width(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @width.setter
+    def width(self, arg1: typing.Any) -> None:
+        ...
+class _MjModelTupleViews:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def adr(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @adr.setter
+    def adr(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def id(self) -> int:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def objid(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @objid.setter
+    def objid(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def objprm(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @objprm.setter
+    def objprm(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def objtype(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @objtype.setter
+    def objtype(self, arg1: typing.Any) -> None:
+        ...
+    @property
+    def size(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @size.setter
+    def size(self, arg1: typing.Any) -> None:
+        ...
+class _MjSolverStatList:
+    __hash__: typing.ClassVar[None] = None
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __getitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> MjSolverStat:
+        ...
+    @typing.overload
+    def __getitem__(self, arg0: slice) -> _MjSolverStatList:
+        ...
+    def __len__(self) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def gradient(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def improvement(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def lineslope(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def nactive(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def nchange(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def neval(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def nupdate(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+class _MjTimerStatList:
+    __hash__: typing.ClassVar[None] = None
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __getitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> MjTimerStat:
+        ...
+    @typing.overload
+    def __getitem__(self, arg0: mujoco._enums.mjtTimer) -> MjTimerStat:
+        ...
+    @typing.overload
+    def __getitem__(self, arg0: slice) -> _MjTimerStatList:
+        ...
+    def __len__(self) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def duration(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    @property
+    def number(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+class _MjWarningStatList:
+    __hash__: typing.ClassVar[None] = None
+    def __eq__(self, arg0: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __getitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> MjWarningStat:
+        ...
+    @typing.overload
+    def __getitem__(self, arg0: mujoco._enums.mjtWarning) -> MjWarningStat:
+        ...
+    @typing.overload
+    def __getitem__(self, arg0: slice) -> _MjWarningStatList:
+        ...
+    def __len__(self) -> int:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def lastinfo(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+    @property
+    def number(self) -> numpy.typing.NDArray[numpy.int32]:
+        ...
+def _recompile_spec_addr(arg0: typing.SupportsInt | typing.SupportsIndex, arg1: MjModel, arg2: MjData) -> tuple:
+    ...
+def mjv_averageCamera(cam1: MjvGLCamera, cam2: MjvGLCamera) -> MjvGLCamera:
+    """
+    Return the average of two OpenGL cameras.
+    """
diff --git a/typings/mujoco/viewer.pyi b/typings/mujoco/viewer.pyi
new file mode 100644
index 0000000..ac5de3b
--- /dev/null
+++ b/typings/mujoco/viewer.pyi
@@ -0,0 +1,145 @@
+"""
+Interactive GUI viewer for MuJoCo.
+"""
+from __future__ import annotations
+import abc as abc
+import atexit as atexit
+import contextlib as contextlib
+import glfw as glfw
+import math as math
+import mujoco as mujoco
+from mujoco import _simulate
+from mujoco._simulate import Simulate as _Simulate
+import numpy as np
+import os as os
+import queue as queue
+import sys as sys
+import threading as threading
+import time as time
+import typing
+import weakref as weakref
+__all__: list[str] = ['CallbackType', 'Handle', 'KeyCallbackType', 'LoaderType', 'MAX_SYNC_MISALIGN', 'PERCENT_REALTIME', 'SIM_REFRESH_FRACTION', 'abc', 'atexit', 'contextlib', 'glfw', 'launch', 'launch_from_path', 'launch_passive', 'math', 'mujoco', 'np', 'os', 'queue', 'sys', 'threading', 'time', 'weakref']
+class Handle:
+    """
+    A handle for interacting with a MuJoCo viewer.
+    """
+    def __enter__(self):
+        ...
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        ...
+    def __init__(self, sim: mujoco._simulate.Simulate, cam: mujoco._structs.MjvCamera, opt: mujoco._structs.MjvOption, pert: mujoco._structs.MjvPerturb, user_scn: typing.Optional[mujoco._structs.MjvScene]):
+        ...
+    def _get_sim(self) -> typing.Optional[mujoco._simulate.Simulate]:
+        ...
+    def clear_figures(self):
+        ...
+    def clear_images(self):
+        ...
+    def clear_texts(self):
+        ...
+    def close(self):
+        ...
+    def is_running(self) -> bool:
+        ...
+    def lock(self):
+        ...
+    def set_figures(self, viewports_figures: typing.Union[typing.Tuple[mujoco._structs.MjrRect, mujoco._structs.MjvFigure], typing.List[typing.Tuple[mujoco._structs.MjrRect, mujoco._structs.MjvFigure]]]):
+        """
+        Overlay figures on the viewer.
+        
+        Args:
+          viewports_figures: Single tuple or list of tuples of (viewport, figure)
+            viewport: Rectangle defining position and size of the figure
+            figure: MjvFigure object containing the figure data to display
+        """
+    def set_images(self, viewports_images: typing.Union[typing.Tuple[mujoco._structs.MjrRect, numpy.ndarray], typing.List[typing.Tuple[mujoco._structs.MjrRect, numpy.ndarray]]]):
+        """
+        Overlay images on the viewer.
+        
+        Args:
+          viewports_images: Single tuple or list of tuples of (viewport, image)
+            viewport: Rectangle defining position and size of the image
+            image: RGB image with shape (height, width, 3)
+        """
+    def set_texts(self, texts: typing.Union[typing.Tuple[typing.Optional[int], typing.Optional[int], typing.Optional[str], typing.Optional[str]], typing.List[typing.Tuple[typing.Optional[int], typing.Optional[int], typing.Optional[str], typing.Optional[str]]]]):
+        """
+        Overlay text on the viewer.
+        
+        Args:
+          texts: Single tuple or list of tuples of (font, gridpos, text1, text2)
+            font: Font style from mujoco.mjtFontScale
+            gridpos: Position of text box from mujoco.mjtGridPos
+            text1: Left text column, defaults to empty string if None
+            text2: Right text column, defaults to empty string if None
+        """
+    def sync(self, state_only: bool = False):
+        ...
+    def update_hfield(self, hfieldid: int):
+        ...
+    def update_mesh(self, meshid: int):
+        ...
+    def update_texture(self, texid: int):
+        ...
+    @property
+    def cam(self):
+        ...
+    @property
+    def d(self):
+        ...
+    @property
+    def m(self):
+        ...
+    @property
+    def opt(self):
+        ...
+    @property
+    def perturb(self):
+        ...
+    @property
+    def user_scn(self):
+        ...
+    @property
+    def viewport(self):
+        ...
+class _MjPythonBase:
+    __abstractmethods__: typing.ClassVar[frozenset]  # value = frozenset()
+    _abc_impl: typing.ClassVar[_abc._abc_data]  # value = <_abc._abc_data object>
+    def launch_on_ui_thread(self, model: mujoco._structs.MjModel, data: mujoco._structs.MjData, handle_return: typing.Optional[ForwardRef('queue.Queue[Handle]')], key_callback: typing.Optional[typing.Callable[[int], NoneType]]):
+        ...
+def _file_loader(path: str) -> typing.Callable[[], typing.Tuple[mujoco._structs.MjModel, mujoco._structs.MjData, str]]:
+    """
+    Loads an MJCF model from file path.
+    """
+def _launch_internal(model: typing.Optional[mujoco._structs.MjModel] = None, data: typing.Optional[mujoco._structs.MjData] = None, *, run_physics_thread: bool, loader: typing.Union[typing.Callable[[], typing.Tuple[mujoco._structs.MjModel, mujoco._structs.MjData]], typing.Callable[[], typing.Tuple[mujoco._structs.MjModel, mujoco._structs.MjData, str]], NoneType] = None, handle_return: typing.Optional[ForwardRef('queue.Queue[Handle]')] = None, key_callback: typing.Optional[typing.Callable[[int], NoneType]] = None, show_left_ui: bool = True, show_right_ui: bool = True) -> None:
+    """
+    Internal API, so that the public API has more readable type annotations.
+    """
+def _physics_loop(simulate: mujoco._simulate.Simulate, loader: typing.Union[typing.Callable[[], typing.Tuple[mujoco._structs.MjModel, mujoco._structs.MjData]], typing.Callable[[], typing.Tuple[mujoco._structs.MjModel, mujoco._structs.MjData, str]], NoneType]):
+    """
+    Physics loop for the GUI, to be run in a separate thread.
+    """
+def _reload(simulate: mujoco._simulate.Simulate, loader: typing.Union[typing.Callable[[], typing.Tuple[mujoco._structs.MjModel, mujoco._structs.MjData]], typing.Callable[[], typing.Tuple[mujoco._structs.MjModel, mujoco._structs.MjData, str]]], notify_loaded: typing.Optional[typing.Callable[[], NoneType]] = None) -> typing.Optional[typing.Tuple[mujoco._structs.MjModel, mujoco._structs.MjData]]:
+    """
+    Internal function for reloading a model in the viewer.
+    """
+def launch(model: typing.Optional[mujoco._structs.MjModel] = None, data: typing.Optional[mujoco._structs.MjData] = None, *, loader: typing.Optional[typing.Callable[[], typing.Tuple[mujoco._structs.MjModel, mujoco._structs.MjData]]] = None, show_left_ui: bool = True, show_right_ui: bool = True) -> None:
+    """
+    Launches the Simulate GUI.
+    """
+def launch_from_path(path: str) -> None:
+    """
+    Launches the Simulate GUI from file path.
+    """
+def launch_passive(model: mujoco._structs.MjModel, data: mujoco._structs.MjData, *, key_callback: typing.Optional[typing.Callable[[int], NoneType]] = None, show_left_ui: bool = True, show_right_ui: bool = True) -> Handle:
+    """
+    Launches a passive Simulate GUI without blocking the running thread.
+    """
+CallbackType: typing._CallableGenericAlias  # value = typing.Callable[[mujoco._structs.MjModel, mujoco._structs.MjData], NoneType]
+KeyCallbackType: typing._CallableGenericAlias  # value = typing.Callable[[int], NoneType]
+LoaderType: typing._CallableGenericAlias  # value = typing.Callable[[], typing.Tuple[mujoco._structs.MjModel, mujoco._structs.MjData]]
+MAX_SYNC_MISALIGN: float = 0.1
+PERCENT_REALTIME: tuple = (100, 80, 66, 50, 40, 33, 25, 20, 16, 13, 10, 8, 6.6, 5, 4, 3.3, 2.5, 2, 1.6, 1.3, 1, 0.8, 0.66, 0.5, 0.4, 0.33, 0.25, 0.2, 0.16, 0.13, 0.1)
+SIM_REFRESH_FRACTION: float = 0.7
+_InternalLoaderType: typing._UnionGenericAlias  # value = typing.Union[typing.Callable[[], typing.Tuple[mujoco._structs.MjModel, mujoco._structs.MjData]], typing.Callable[[], typing.Tuple[mujoco._structs.MjModel, mujoco._structs.MjData, str]]]
+_LoaderWithPathType: typing._CallableGenericAlias  # value = typing.Callable[[], typing.Tuple[mujoco._structs.MjModel, mujoco._structs.MjData, str]]
+_MJPYTHON = None
diff --git a/typings/postprocess_stubs.py b/typings/postprocess_stubs.py
new file mode 100644
index 0000000..426730d
--- /dev/null
+++ b/typings/postprocess_stubs.py
@@ -0,0 +1,104 @@
+"""Make the generated MuJoCo stubs platform-independent and reproducible.
+
+``pybind11-stubgen`` introspects the installed ``mujoco`` package, producing two
+kinds of machine-specific output:
+
+1. The active OpenGL backend is baked in: ``mujoco.cgl`` on macOS,
+   ``mujoco.glfw`` on Linux (or ``mujoco.egl`` / ``mujoco.osmesa`` depending on
+   ``MUJOCO_GL``). mjlab does not type-check against the rendering backend, so we
+   drop those stubs and the ``__init__.pyi`` imports referencing them.
+2. Absolute install paths and live object reprs (memory addresses) are embedded
+   as default values and ``# value = ...`` comments. These vary by machine and
+   run, so we strip them.
+
+What remains is a deterministic set of physics-binding stubs that is identical
+on every platform, which lets CI regenerate them and fail if they drift from the
+installed mujoco version.
+"""
+
+from __future__ import annotations
+
+import re
+import shutil
+from pathlib import Path
+
+STUB_DIR = Path(__file__).parent / "mujoco"
+
+# OpenGL context backends mujoco may expose, only one of which exists per
+# platform / MUJOCO_GL setting.
+BACKENDS = ("cgl", "egl", "glfw", "glx", "osmesa")
+
+# Backend modules plus the rendering stubs that import them. None are needed to
+# type-check mjlab, and all are platform-specific, so remove them entirely.
+REMOVE = (*BACKENDS, "gl_context.pyi", "renderer.pyi", "rendering")
+
+# Backend imports in __init__.pyi, e.g. "from mujoco.cgl import GLContext" and
+# "from . import cgl", along with the names they contribute to __all__.
+DROP_IMPORT = re.compile(
+  rf"^(?:from mujoco\.(?:{'|'.join(BACKENDS)}) import GLContext"
+  rf"|from \. import (?:{'|'.join(BACKENDS)}))$"
+)
+# Module-level constants in __init__.pyi that exist only on some platforms
+# (macOS exposes is_rosetta / proc_translated for Rosetta detection; Linux does
+# not). Remove them so the stubs match on every platform.
+PLATFORM_ONLY = ("is_rosetta", "proc_translated")
+PLATFORM_ONLY_DEF = re.compile(rf"^(?:{'|'.join(PLATFORM_ONLY)})\b")
+
+DROP_FROM_ALL = ("GLContext", *BACKENDS, *PLATFORM_ONLY)
+
+# _SYSTEM holds the host platform name ('Darwin' / 'Linux'); drop the value.
+SYSTEM_DEFAULT = re.compile(r"^(_SYSTEM: str) = '\w+'$")
+
+# A trailing "# value = ..." comment that captures a live object repr.
+VALUE_COMMENT = re.compile(r" {2,}# value = .*$")
+
+# A string constant whose default is an absolute install path.
+PATH_DEFAULT = re.compile(
+  r"^(\s*\w+: str) = '[^']*(?:site-packages|/Users/|/home/)[^']*'\s*$"
+)
+
+
+def remove_backend_stubs() -> None:
+  for name in REMOVE:
+    target = STUB_DIR / name
+    if target.is_dir():
+      shutil.rmtree(target)
+    elif target.exists():
+      target.unlink()
+
+
+def patch_init() -> None:
+  init = STUB_DIR / "__init__.pyi"
+  out = []
+  for line in init.read_text().splitlines():
+    if DROP_IMPORT.match(line.strip()) or PLATFORM_ONLY_DEF.match(line):
+      continue
+    line = SYSTEM_DEFAULT.sub(r"\1", line)
+    if line.startswith("__all__"):
+      for name in DROP_FROM_ALL:
+        line = line.replace(f"'{name}', ", "")
+    out.append(line)
+  init.write_text("\n".join(out) + "\n")
+
+
+def sanitize_machine_specific() -> None:
+  for path in STUB_DIR.rglob("*.pyi"):
+    out = []
+    for line in path.read_text().splitlines():
+      if "# value = " in line and ("site-packages" in line or "0x" in line):
+        line = VALUE_COMMENT.sub("", line)
+      match = PATH_DEFAULT.match(line)
+      if match:
+        line = match.group(1)
+      out.append(line)
+    path.write_text("\n".join(out) + "\n")
+
+
+def main() -> None:
+  remove_backend_stubs()
+  patch_init()
+  sanitize_machine_specific()
+
+
+if __name__ == "__main__":
+  main()
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 0000000..26e32b2
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,5065 @@
+version = 1
+revision = 3
+requires-python = ">=3.10, <3.14"
+resolution-markers = [
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+required-markers = [
+    "platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "platform_machine == 'x86_64' and sys_platform == 'linux'",
+]
+conflicts = [[
+    { package = "mjlab", extra = "cpu" },
+    { package = "mjlab", extra = "cu128" },
+]]
+
+[manifest]
+constraints = [
+    { name = "gitpython", specifier = ">=3.1.57" },
+    { name = "lxml", specifier = ">=6.1.0" },
+]
+
+[[package]]
+name = "absl-py"
+version = "2.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/10/2a/c93173ffa1b39c1d0395b7e842bbdc62e556ca9d8d3b5572926f3e4ca752/absl_py-2.3.1.tar.gz", hash = "sha256:a97820526f7fbfd2ec1bce83f3f25e3a14840dac0d8e02a0b71cd75db3f77fc9", size = 116588, upload-time = "2025-07-03T09:31:44.05Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/aa/ba0014cc4659328dc818a28827be78e6d97312ab0cb98105a770924dc11e/absl_py-2.3.1-py3-none-any.whl", hash = "sha256:eeecf07f0c2a93ace0772c92e596ace6d3d3996c042b2128459aaae2a76de11d", size = 135811, upload-time = "2025-07-03T09:31:42.253Z" },
+]
+
+[[package]]
+name = "accessible-pygments"
+version = "0.0.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bc/c1/bbac6a50d02774f91572938964c582fff4270eee73ab822a4aeea4d8b11b/accessible_pygments-0.0.5.tar.gz", hash = "sha256:40918d3e6a2b619ad424cb91e556bd3bd8865443d9f22f1dcdf79e33c8046872", size = 1377899, upload-time = "2024-05-10T11:23:10.216Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8d/3f/95338030883d8c8b91223b4e21744b04d11b161a3ef117295d8241f50ab4/accessible_pygments-0.0.5-py3-none-any.whl", hash = "sha256:88ae3211e68a1d0b011504b2ffc1691feafce124b845bd072ab6f9f66f34d4b7", size = 1395903, upload-time = "2024-05-10T11:23:08.421Z" },
+]
+
+[[package]]
+name = "alabaster"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/f8/d9c74d0daf3f742840fd818d69cfae176fa332022fd44e3469487d5a9420/alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e", size = 24210, upload-time = "2024-07-26T18:15:03.762Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929, upload-time = "2024-07-26T18:15:02.05Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "exceptiongroup", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "idna" },
+    { name = "sniffio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c6/78/7d432127c41b50bccba979505f272c16cbcadcc33645d5fa3a738110ae75/anyio-4.11.0.tar.gz", hash = "sha256:82a8d0b81e318cc5ce71a5f1f8b5c4e63619620b63141ef8c995fa0db95a57c4", size = 219094, upload-time = "2025-09-23T09:19:12.58Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/15/b3/9b1a8074496371342ec1e796a96f99c82c945a339cd81a8e73de28b4cf9e/anyio-4.11.0-py3-none-any.whl", hash = "sha256:0287e96f4d26d4149305414d4e3bc32f0dcd0862365a4bddea19d7a1ec38c4fc", size = 109097, upload-time = "2025-09-23T09:19:10.601Z" },
+]
+
+[[package]]
+name = "asttokens"
+version = "3.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978, upload-time = "2024-11-30T04:30:14.439Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918, upload-time = "2024-11-30T04:30:10.946Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "25.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" },
+]
+
+[[package]]
+name = "autodocsumm"
+version = "0.2.14"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/03/96/92afe8a7912b327c01f0a8b6408c9556ee13b1aba5b98d587ac7327ff32d/autodocsumm-0.2.14.tar.gz", hash = "sha256:2839a9d4facc3c4eccd306c08695540911042b46eeafcdc3203e6d0bab40bc77", size = 46357, upload-time = "2024-10-23T18:51:47.369Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/bc/3f66af9beb683728e06ca08797e4e9d3e44f432f339718cae3ba856a9cad/autodocsumm-0.2.14-py3-none-any.whl", hash = "sha256:3bad8717fc5190802c60392a7ab04b9f3c97aa9efa8b3780b3d81d615bfe5dc0", size = 14640, upload-time = "2024-10-23T18:51:45.115Z" },
+]
+
+[[package]]
+name = "babel"
+version = "2.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/6b/d52e42361e1aa00709585ecc30b3f9684b3ab62530771402248b1b1d6240/babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d", size = 9951852, upload-time = "2025-02-01T15:17:41.026Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537, upload-time = "2025-02-01T15:17:37.39Z" },
+]
+
+[[package]]
+name = "bcrypt"
+version = "5.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d4/36/3329e2518d70ad8e2e5817d5a4cac6bba05a47767ec416c7d020a965f408/bcrypt-5.0.0.tar.gz", hash = "sha256:f748f7c2d6fd375cc93d3fba7ef4a9e3a092421b8dbf34d8d4dc06be9492dfdd", size = 25386, upload-time = "2025-09-25T19:50:47.829Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/13/85/3e65e01985fddf25b64ca67275bb5bdb4040bd1a53b66d355c6c37c8a680/bcrypt-5.0.0-cp313-cp313t-macosx_10_12_universal2.whl", hash = "sha256:f3c08197f3039bec79cee59a606d62b96b16669cff3949f21e74796b6e3cd2be", size = 481806, upload-time = "2025-09-25T19:49:05.102Z" },
+    { url = "https://files.pythonhosted.org/packages/44/dc/01eb79f12b177017a726cbf78330eb0eb442fae0e7b3dfd84ea2849552f3/bcrypt-5.0.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:200af71bc25f22006f4069060c88ed36f8aa4ff7f53e67ff04d2ab3f1e79a5b2", size = 268626, upload-time = "2025-09-25T19:49:06.723Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/cf/e82388ad5959c40d6afd94fb4743cc077129d45b952d46bdc3180310e2df/bcrypt-5.0.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:baade0a5657654c2984468efb7d6c110db87ea63ef5a4b54732e7e337253e44f", size = 271853, upload-time = "2025-09-25T19:49:08.028Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/86/7134b9dae7cf0efa85671651341f6afa695857fae172615e960fb6a466fa/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:c58b56cdfb03202b3bcc9fd8daee8e8e9b6d7e3163aa97c631dfcfcc24d36c86", size = 269793, upload-time = "2025-09-25T19:49:09.727Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/82/6296688ac1b9e503d034e7d0614d56e80c5d1a08402ff856a4549cb59207/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4bfd2a34de661f34d0bda43c3e4e79df586e4716ef401fe31ea39d69d581ef23", size = 289930, upload-time = "2025-09-25T19:49:11.204Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/18/884a44aa47f2a3b88dd09bc05a1e40b57878ecd111d17e5bba6f09f8bb77/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:ed2e1365e31fc73f1825fa830f1c8f8917ca1b3ca6185773b349c20fd606cec2", size = 272194, upload-time = "2025-09-25T19:49:12.524Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/8f/371a3ab33c6982070b674f1788e05b656cfbf5685894acbfef0c65483a59/bcrypt-5.0.0-cp313-cp313t-manylinux_2_34_aarch64.whl", hash = "sha256:83e787d7a84dbbfba6f250dd7a5efd689e935f03dd83b0f919d39349e1f23f83", size = 269381, upload-time = "2025-09-25T19:49:14.308Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/34/7e4e6abb7a8778db6422e88b1f06eb07c47682313997ee8a8f9352e5a6f1/bcrypt-5.0.0-cp313-cp313t-manylinux_2_34_x86_64.whl", hash = "sha256:137c5156524328a24b9fac1cb5db0ba618bc97d11970b39184c1d87dc4bf1746", size = 271750, upload-time = "2025-09-25T19:49:15.584Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/1b/54f416be2499bd72123c70d98d36c6cd61a4e33d9b89562c22481c81bb30/bcrypt-5.0.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:38cac74101777a6a7d3b3e3cfefa57089b5ada650dce2baf0cbdd9d65db22a9e", size = 303757, upload-time = "2025-09-25T19:49:17.244Z" },
+    { url = "https://files.pythonhosted.org/packages/13/62/062c24c7bcf9d2826a1a843d0d605c65a755bc98002923d01fd61270705a/bcrypt-5.0.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:d8d65b564ec849643d9f7ea05c6d9f0cd7ca23bdd4ac0c2dbef1104ab504543d", size = 306740, upload-time = "2025-09-25T19:49:18.693Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/c8/1fdbfc8c0f20875b6b4020f3c7dc447b8de60aa0be5faaf009d24242aec9/bcrypt-5.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:741449132f64b3524e95cd30e5cd3343006ce146088f074f31ab26b94e6c75ba", size = 334197, upload-time = "2025-09-25T19:49:20.523Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/c1/8b84545382d75bef226fbc6588af0f7b7d095f7cd6a670b42a86243183cd/bcrypt-5.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:212139484ab3207b1f0c00633d3be92fef3c5f0af17cad155679d03ff2ee1e41", size = 352974, upload-time = "2025-09-25T19:49:22.254Z" },
+    { url = "https://files.pythonhosted.org/packages/10/a6/ffb49d4254ed085e62e3e5dd05982b4393e32fe1e49bb1130186617c29cd/bcrypt-5.0.0-cp313-cp313t-win32.whl", hash = "sha256:9d52ed507c2488eddd6a95bccee4e808d3234fa78dd370e24bac65a21212b861", size = 148498, upload-time = "2025-09-25T19:49:24.134Z" },
+    { url = "https://files.pythonhosted.org/packages/48/a9/259559edc85258b6d5fc5471a62a3299a6aa37a6611a169756bf4689323c/bcrypt-5.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f6984a24db30548fd39a44360532898c33528b74aedf81c26cf29c51ee47057e", size = 145853, upload-time = "2025-09-25T19:49:25.702Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/df/9714173403c7e8b245acf8e4be8876aac64a209d1b392af457c79e60492e/bcrypt-5.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:9fffdb387abe6aa775af36ef16f55e318dcda4194ddbf82007a6f21da29de8f5", size = 139626, upload-time = "2025-09-25T19:49:26.928Z" },
+    { url = "https://files.pythonhosted.org/packages/84/29/6237f151fbfe295fe3e074ecc6d44228faa1e842a81f6d34a02937ee1736/bcrypt-5.0.0-cp38-abi3-macosx_10_12_universal2.whl", hash = "sha256:fc746432b951e92b58317af8e0ca746efe93e66555f1b40888865ef5bf56446b", size = 494553, upload-time = "2025-09-25T19:49:49.006Z" },
+    { url = "https://files.pythonhosted.org/packages/45/b6/4c1205dde5e464ea3bd88e8742e19f899c16fa8916fb8510a851fae985b5/bcrypt-5.0.0-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c2388ca94ffee269b6038d48747f4ce8df0ffbea43f31abfa18ac72f0218effb", size = 275009, upload-time = "2025-09-25T19:49:50.581Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/71/427945e6ead72ccffe77894b2655b695ccf14ae1866cd977e185d606dd2f/bcrypt-5.0.0-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:560ddb6ec730386e7b3b26b8b4c88197aaed924430e7b74666a586ac997249ef", size = 278029, upload-time = "2025-09-25T19:49:52.533Z" },
+    { url = "https://files.pythonhosted.org/packages/17/72/c344825e3b83c5389a369c8a8e58ffe1480b8a699f46c127c34580c4666b/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:d79e5c65dcc9af213594d6f7f1fa2c98ad3fc10431e7aa53c176b441943efbdd", size = 275907, upload-time = "2025-09-25T19:49:54.709Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/7e/d4e47d2df1641a36d1212e5c0514f5291e1a956a7749f1e595c07a972038/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2b732e7d388fa22d48920baa267ba5d97cca38070b69c0e2d37087b381c681fd", size = 296500, upload-time = "2025-09-25T19:49:56.013Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/c3/0ae57a68be2039287ec28bc463b82e4b8dc23f9d12c0be331f4782e19108/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:0c8e093ea2532601a6f686edbc2c6b2ec24131ff5c52f7610dd64fa4553b5464", size = 278412, upload-time = "2025-09-25T19:49:57.356Z" },
+    { url = "https://files.pythonhosted.org/packages/45/2b/77424511adb11e6a99e3a00dcc7745034bee89036ad7d7e255a7e47be7d8/bcrypt-5.0.0-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:5b1589f4839a0899c146e8892efe320c0fa096568abd9b95593efac50a87cb75", size = 275486, upload-time = "2025-09-25T19:49:59.116Z" },
+    { url = "https://files.pythonhosted.org/packages/43/0a/405c753f6158e0f3f14b00b462d8bca31296f7ecfc8fc8bc7919c0c7d73a/bcrypt-5.0.0-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:89042e61b5e808b67daf24a434d89bab164d4de1746b37a8d173b6b14f3db9ff", size = 277940, upload-time = "2025-09-25T19:50:00.869Z" },
+    { url = "https://files.pythonhosted.org/packages/62/83/b3efc285d4aadc1fa83db385ec64dcfa1707e890eb42f03b127d66ac1b7b/bcrypt-5.0.0-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:e3cf5b2560c7b5a142286f69bde914494b6d8f901aaa71e453078388a50881c4", size = 310776, upload-time = "2025-09-25T19:50:02.393Z" },
+    { url = "https://files.pythonhosted.org/packages/95/7d/47ee337dacecde6d234890fe929936cb03ebc4c3a7460854bbd9c97780b8/bcrypt-5.0.0-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f632fd56fc4e61564f78b46a2269153122db34988e78b6be8b32d28507b7eaeb", size = 312922, upload-time = "2025-09-25T19:50:04.232Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/3a/43d494dfb728f55f4e1cf8fd435d50c16a2d75493225b54c8d06122523c6/bcrypt-5.0.0-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:801cad5ccb6b87d1b430f183269b94c24f248dddbbc5c1f78b6ed231743e001c", size = 341367, upload-time = "2025-09-25T19:50:05.559Z" },
+    { url = "https://files.pythonhosted.org/packages/55/ab/a0727a4547e383e2e22a630e0f908113db37904f58719dc48d4622139b5c/bcrypt-5.0.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3cf67a804fc66fc217e6914a5635000259fbbbb12e78a99488e4d5ba445a71eb", size = 359187, upload-time = "2025-09-25T19:50:06.916Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/bb/461f352fdca663524b4643d8b09e8435b4990f17fbf4fea6bc2a90aa0cc7/bcrypt-5.0.0-cp38-abi3-win32.whl", hash = "sha256:3abeb543874b2c0524ff40c57a4e14e5d3a66ff33fb423529c88f180fd756538", size = 153752, upload-time = "2025-09-25T19:50:08.515Z" },
+    { url = "https://files.pythonhosted.org/packages/41/aa/4190e60921927b7056820291f56fc57d00d04757c8b316b2d3c0d1d6da2c/bcrypt-5.0.0-cp38-abi3-win_amd64.whl", hash = "sha256:35a77ec55b541e5e583eb3436ffbbf53b0ffa1fa16ca6782279daf95d146dcd9", size = 150881, upload-time = "2025-09-25T19:50:09.742Z" },
+    { url = "https://files.pythonhosted.org/packages/54/12/cd77221719d0b39ac0b55dbd39358db1cd1246e0282e104366ebbfb8266a/bcrypt-5.0.0-cp38-abi3-win_arm64.whl", hash = "sha256:cde08734f12c6a4e28dc6755cd11d3bdfea608d93d958fffbe95a7026ebe4980", size = 144931, upload-time = "2025-09-25T19:50:11.016Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ba/2af136406e1c3839aea9ecadc2f6be2bcd1eff255bd451dd39bcf302c47a/bcrypt-5.0.0-cp39-abi3-macosx_10_12_universal2.whl", hash = "sha256:0c418ca99fd47e9c59a301744d63328f17798b5947b0f791e9af3c1c499c2d0a", size = 495313, upload-time = "2025-09-25T19:50:12.309Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ee/2f4985dbad090ace5ad1f7dd8ff94477fe089b5fab2040bd784a3d5f187b/bcrypt-5.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ddb4e1500f6efdd402218ffe34d040a1196c072e07929b9820f363a1fd1f4191", size = 275290, upload-time = "2025-09-25T19:50:13.673Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/6e/b77ade812672d15cf50842e167eead80ac3514f3beacac8902915417f8b7/bcrypt-5.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7aeef54b60ceddb6f30ee3db090351ecf0d40ec6e2abf41430997407a46d2254", size = 278253, upload-time = "2025-09-25T19:50:15.089Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c4/ed00ed32f1040f7990dac7115f82273e3c03da1e1a1587a778d8cea496d8/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:f0ce778135f60799d89c9693b9b398819d15f1921ba15fe719acb3178215a7db", size = 276084, upload-time = "2025-09-25T19:50:16.699Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/c4/fa6e16145e145e87f1fa351bbd54b429354fd72145cd3d4e0c5157cf4c70/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a71f70ee269671460b37a449f5ff26982a6f2ba493b3eabdd687b4bf35f875ac", size = 297185, upload-time = "2025-09-25T19:50:18.525Z" },
+    { url = "https://files.pythonhosted.org/packages/24/b4/11f8a31d8b67cca3371e046db49baa7c0594d71eb40ac8121e2fc0888db0/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f8429e1c410b4073944f03bd778a9e066e7fad723564a52ff91841d278dfc822", size = 278656, upload-time = "2025-09-25T19:50:19.809Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/31/79f11865f8078e192847d2cb526e3fa27c200933c982c5b2869720fa5fce/bcrypt-5.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:edfcdcedd0d0f05850c52ba3127b1fce70b9f89e0fe5ff16517df7e81fa3cbb8", size = 275662, upload-time = "2025-09-25T19:50:21.567Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/8d/5e43d9584b3b3591a6f9b68f755a4da879a59712981ef5ad2a0ac1379f7a/bcrypt-5.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:611f0a17aa4a25a69362dcc299fda5c8a3d4f160e2abb3831041feb77393a14a", size = 278240, upload-time = "2025-09-25T19:50:23.305Z" },
+    { url = "https://files.pythonhosted.org/packages/89/48/44590e3fc158620f680a978aafe8f87a4c4320da81ed11552f0323aa9a57/bcrypt-5.0.0-cp39-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:db99dca3b1fdc3db87d7c57eac0c82281242d1eabf19dcb8a6b10eb29a2e72d1", size = 311152, upload-time = "2025-09-25T19:50:24.597Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/85/e4fbfc46f14f47b0d20493669a625da5827d07e8a88ee460af6cd9768b44/bcrypt-5.0.0-cp39-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:5feebf85a9cefda32966d8171f5db7e3ba964b77fdfe31919622256f80f9cf42", size = 313284, upload-time = "2025-09-25T19:50:26.268Z" },
+    { url = "https://files.pythonhosted.org/packages/25/ae/479f81d3f4594456a01ea2f05b132a519eff9ab5768a70430fa1132384b1/bcrypt-5.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:3ca8a166b1140436e058298a34d88032ab62f15aae1c598580333dc21d27ef10", size = 341643, upload-time = "2025-09-25T19:50:28.02Z" },
+    { url = "https://files.pythonhosted.org/packages/df/d2/36a086dee1473b14276cd6ea7f61aef3b2648710b5d7f1c9e032c29b859f/bcrypt-5.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:61afc381250c3182d9078551e3ac3a41da14154fbff647ddf52a769f588c4172", size = 359698, upload-time = "2025-09-25T19:50:31.347Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/f6/688d2cd64bfd0b14d805ddb8a565e11ca1fb0fd6817175d58b10052b6d88/bcrypt-5.0.0-cp39-abi3-win32.whl", hash = "sha256:64d7ce196203e468c457c37ec22390f1a61c85c6f0b8160fd752940ccfb3a683", size = 153725, upload-time = "2025-09-25T19:50:34.384Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/b9/9d9a641194a730bda138b3dfe53f584d61c58cd5230e37566e83ec2ffa0d/bcrypt-5.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:64ee8434b0da054d830fa8e89e1c8bf30061d539044a39524ff7dec90481e5c2", size = 150912, upload-time = "2025-09-25T19:50:35.69Z" },
+    { url = "https://files.pythonhosted.org/packages/27/44/d2ef5e87509158ad2187f4dd0852df80695bb1ee0cfe0a684727b01a69e0/bcrypt-5.0.0-cp39-abi3-win_arm64.whl", hash = "sha256:f2347d3534e76bf50bca5500989d6c1d05ed64b440408057a37673282c654927", size = 144953, upload-time = "2025-09-25T19:50:37.32Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/75/4aa9f5a4d40d762892066ba1046000b329c7cd58e888a6db878019b282dc/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:7edda91d5ab52b15636d9c30da87d2cc84f426c72b9dba7a9b4fe142ba11f534", size = 271180, upload-time = "2025-09-25T19:50:38.575Z" },
+    { url = "https://files.pythonhosted.org/packages/54/79/875f9558179573d40a9cc743038ac2bf67dfb79cecb1e8b5d70e88c94c3d/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:046ad6db88edb3c5ece4369af997938fb1c19d6a699b9c1b27b0db432faae4c4", size = 273791, upload-time = "2025-09-25T19:50:39.913Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/fe/975adb8c216174bf70fc17535f75e85ac06ed5252ea077be10d9cff5ce24/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:dcd58e2b3a908b5ecc9b9df2f0085592506ac2d5110786018ee5e160f28e0911", size = 270746, upload-time = "2025-09-25T19:50:43.306Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/f8/972c96f5a2b6c4b3deca57009d93e946bbdbe2241dca9806d502f29dd3ee/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:6b8f520b61e8781efee73cba14e3e8c9556ccfb375623f4f97429544734545b4", size = 273375, upload-time = "2025-09-25T19:50:45.43Z" },
+]
+
+[[package]]
+name = "beautifulsoup4"
+version = "4.14.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "soupsieve" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b0/1c6a16426d389813b48d95e26898aff79abbde42ad353958ad95cc8c9b21/beautifulsoup4-4.14.3.tar.gz", hash = "sha256:6292b1c5186d356bba669ef9f7f051757099565ad9ada5dd630bd9de5fa7fb86", size = 627737, upload-time = "2025-11-30T15:08:26.084Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1a/39/47f9197bdd44df24d67ac8893641e16f386c984a0619ef2ee4c51fbbc019/beautifulsoup4-4.14.3-py3-none-any.whl", hash = "sha256:0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb", size = 107721, upload-time = "2025-11-30T15:08:24.087Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2025.10.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4c/5b/b6ce21586237c77ce67d01dc5507039d444b630dd76611bbca2d8e5dcd91/certifi-2025.10.5.tar.gz", hash = "sha256:47c09d31ccf2acf0be3f701ea53595ee7e0b8fa08801c6624be771df09ae7b43", size = 164519, upload-time = "2025-10-05T04:12:15.808Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e4/37/af0d2ef3967ac0d6113837b44a4f0bfe1328c2b9763bd5b1744520e5cfed/certifi-2025.10.5-py3-none-any.whl", hash = "sha256:0f212c2744a9bb6de0c56639a6f68afe01ecd92d91f14ae897c4fe7bbeeef0de", size = 163286, upload-time = "2025-10-05T04:12:14.03Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/93/d7/516d984057745a6cd96575eea814fe1edd6646ee6efd552fb7b0921dec83/cffi-2.0.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44", size = 184283, upload-time = "2025-09-08T23:22:08.01Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/84/ad6a0b408daa859246f57c03efd28e5dd1b33c21737c2db84cae8c237aa5/cffi-2.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49", size = 180504, upload-time = "2025-09-08T23:22:10.637Z" },
+    { url = "https://files.pythonhosted.org/packages/50/bd/b1a6362b80628111e6653c961f987faa55262b4002fcec42308cad1db680/cffi-2.0.0-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:53f77cbe57044e88bbd5ed26ac1d0514d2acf0591dd6bb02a3ae37f76811b80c", size = 208811, upload-time = "2025-09-08T23:22:12.267Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/27/6933a8b2562d7bd1fb595074cf99cc81fc3789f6a6c05cdabb46284a3188/cffi-2.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3e837e369566884707ddaf85fc1744b47575005c0a229de3327f8f9a20f4efeb", size = 216402, upload-time = "2025-09-08T23:22:13.455Z" },
+    { url = "https://files.pythonhosted.org/packages/05/eb/b86f2a2645b62adcfff53b0dd97e8dfafb5c8aa864bd0d9a2c2049a0d551/cffi-2.0.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5eda85d6d1879e692d546a078b44251cdd08dd1cfb98dfb77b670c97cee49ea0", size = 203217, upload-time = "2025-09-08T23:22:14.596Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/e0/6cbe77a53acf5acc7c08cc186c9928864bd7c005f9efd0d126884858a5fe/cffi-2.0.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9332088d75dc3241c702d852d4671613136d90fa6881da7d770a483fd05248b4", size = 203079, upload-time = "2025-09-08T23:22:15.769Z" },
+    { url = "https://files.pythonhosted.org/packages/98/29/9b366e70e243eb3d14a5cb488dfd3a0b6b2f1fb001a203f653b93ccfac88/cffi-2.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc7de24befaeae77ba923797c7c87834c73648a05a4bde34b3b7e5588973a453", size = 216475, upload-time = "2025-09-08T23:22:17.427Z" },
+    { url = "https://files.pythonhosted.org/packages/21/7a/13b24e70d2f90a322f2900c5d8e1f14fa7e2a6b3332b7309ba7b2ba51a5a/cffi-2.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cf364028c016c03078a23b503f02058f1814320a56ad535686f90565636a9495", size = 218829, upload-time = "2025-09-08T23:22:19.069Z" },
+    { url = "https://files.pythonhosted.org/packages/60/99/c9dc110974c59cc981b1f5b66e1d8af8af764e00f0293266824d9c4254bc/cffi-2.0.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e11e82b744887154b182fd3e7e8512418446501191994dbf9c9fc1f32cc8efd5", size = 211211, upload-time = "2025-09-08T23:22:20.588Z" },
+    { url = "https://files.pythonhosted.org/packages/49/72/ff2d12dbf21aca1b32a40ed792ee6b40f6dc3a9cf1644bd7ef6e95e0ac5e/cffi-2.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8ea985900c5c95ce9db1745f7933eeef5d314f0565b27625d9a10ec9881e1bfb", size = 218036, upload-time = "2025-09-08T23:22:22.143Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/cc/027d7fb82e58c48ea717149b03bcadcbdc293553edb283af792bd4bcbb3f/cffi-2.0.0-cp310-cp310-win32.whl", hash = "sha256:1f72fb8906754ac8a2cc3f9f5aaa298070652a0ffae577e0ea9bd480dc3c931a", size = 172184, upload-time = "2025-09-08T23:22:23.328Z" },
+    { url = "https://files.pythonhosted.org/packages/33/fa/072dd15ae27fbb4e06b437eb6e944e75b068deb09e2a2826039e49ee2045/cffi-2.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:b18a3ed7d5b3bd8d9ef7a8cb226502c6bf8308df1525e1cc676c3680e7176739", size = 182790, upload-time = "2025-09-08T23:22:24.752Z" },
+    { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" },
+    { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" },
+    { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" },
+    { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" },
+    { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" },
+    { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" },
+    { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" },
+    { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" },
+    { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" },
+    { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" },
+    { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" },
+    { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" },
+]
+
+[[package]]
+name = "cfgv"
+version = "3.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/11/74/539e56497d9bd1d484fd863dd69cbbfa653cd2aa27abfe35653494d85e94/cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560", size = 7114, upload-time = "2023-08-12T20:38:17.776Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c5/55/51844dd50c4fc7a33b653bfaba4c2456f06955289ca770a5dbd5fd267374/cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9", size = 7249, upload-time = "2023-08-12T20:38:16.269Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1f/b8/6d51fc1d52cbd52cd4ccedd5b5b2f0f6a11bbf6765c782298b0f3e808541/charset_normalizer-3.4.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e824f1492727fa856dd6eda4f7cee25f8518a12f3c4a56a74e8095695089cf6d", size = 209709, upload-time = "2025-10-14T04:40:11.385Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/af/1f9d7f7faafe2ddfb6f72a2e07a548a629c61ad510fe60f9630309908fef/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4bd5d4137d500351a30687c2d3971758aac9a19208fc110ccb9d7188fbe709e8", size = 148814, upload-time = "2025-10-14T04:40:13.135Z" },
+    { url = "https://files.pythonhosted.org/packages/79/3d/f2e3ac2bbc056ca0c204298ea4e3d9db9b4afe437812638759db2c976b5f/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:027f6de494925c0ab2a55eab46ae5129951638a49a34d87f4c3eda90f696b4ad", size = 144467, upload-time = "2025-10-14T04:40:14.728Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/85/1bf997003815e60d57de7bd972c57dc6950446a3e4ccac43bc3070721856/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f820802628d2694cb7e56db99213f930856014862f3fd943d290ea8438d07ca8", size = 162280, upload-time = "2025-10-14T04:40:16.14Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/8e/6aa1952f56b192f54921c436b87f2aaf7c7a7c3d0d1a765547d64fd83c13/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:798d75d81754988d2565bff1b97ba5a44411867c0cf32b77a7e8f8d84796b10d", size = 159454, upload-time = "2025-10-14T04:40:17.567Z" },
+    { url = "https://files.pythonhosted.org/packages/36/3b/60cbd1f8e93aa25d1c669c649b7a655b0b5fb4c571858910ea9332678558/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d1bb833febdff5c8927f922386db610b49db6e0d4f4ee29601d71e7c2694313", size = 153609, upload-time = "2025-10-14T04:40:19.08Z" },
+    { url = "https://files.pythonhosted.org/packages/64/91/6a13396948b8fd3c4b4fd5bc74d045f5637d78c9675585e8e9fbe5636554/charset_normalizer-3.4.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9cd98cdc06614a2f768d2b7286d66805f94c48cde050acdbbb7db2600ab3197e", size = 151849, upload-time = "2025-10-14T04:40:20.607Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/7a/59482e28b9981d105691e968c544cc0df3b7d6133152fb3dcdc8f135da7a/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:077fbb858e903c73f6c9db43374fd213b0b6a778106bc7032446a8e8b5b38b93", size = 151586, upload-time = "2025-10-14T04:40:21.719Z" },
+    { url = "https://files.pythonhosted.org/packages/92/59/f64ef6a1c4bdd2baf892b04cd78792ed8684fbc48d4c2afe467d96b4df57/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:244bfb999c71b35de57821b8ea746b24e863398194a4014e4c76adc2bbdfeff0", size = 145290, upload-time = "2025-10-14T04:40:23.069Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/63/3bf9f279ddfa641ffa1962b0db6a57a9c294361cc2f5fcac997049a00e9c/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:64b55f9dce520635f018f907ff1b0df1fdc31f2795a922fb49dd14fbcdf48c84", size = 163663, upload-time = "2025-10-14T04:40:24.17Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/09/c9e38fc8fa9e0849b172b581fd9803bdf6e694041127933934184e19f8c3/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:faa3a41b2b66b6e50f84ae4a68c64fcd0c44355741c6374813a800cd6695db9e", size = 151964, upload-time = "2025-10-14T04:40:25.368Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d1/d28b747e512d0da79d8b6a1ac18b7ab2ecfd81b2944c4c710e166d8dd09c/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:6515f3182dbe4ea06ced2d9e8666d97b46ef4c75e326b79bb624110f122551db", size = 161064, upload-time = "2025-10-14T04:40:26.806Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/9a/31d62b611d901c3b9e5500c36aab0ff5eb442043fb3a1c254200d3d397d9/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cc00f04ed596e9dc0da42ed17ac5e596c6ccba999ba6bd92b0e0aef2f170f2d6", size = 155015, upload-time = "2025-10-14T04:40:28.284Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f3/107e008fa2bff0c8b9319584174418e5e5285fef32f79d8ee6a430d0039c/charset_normalizer-3.4.4-cp310-cp310-win32.whl", hash = "sha256:f34be2938726fc13801220747472850852fe6b1ea75869a048d6f896838c896f", size = 99792, upload-time = "2025-10-14T04:40:29.613Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/66/e396e8a408843337d7315bab30dbf106c38966f1819f123257f5520f8a96/charset_normalizer-3.4.4-cp310-cp310-win_amd64.whl", hash = "sha256:a61900df84c667873b292c3de315a786dd8dac506704dea57bc957bd31e22c7d", size = 107198, upload-time = "2025-10-14T04:40:30.644Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/58/01b4f815bf0312704c267f2ccb6e5d42bcc7752340cd487bc9f8c3710597/charset_normalizer-3.4.4-cp310-cp310-win_arm64.whl", hash = "sha256:cead0978fc57397645f12578bfd2d5ea9138ea0fac82b2f63f7f7c6877986a69", size = 100262, upload-time = "2025-10-14T04:40:32.108Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/27/c6491ff4954e58a10f69ad90aca8a1b6fe9c5d3c6f380907af3c37435b59/charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8", size = 206988, upload-time = "2025-10-14T04:40:33.79Z" },
+    { url = "https://files.pythonhosted.org/packages/94/59/2e87300fe67ab820b5428580a53cad894272dbb97f38a7a814a2a1ac1011/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0", size = 147324, upload-time = "2025-10-14T04:40:34.961Z" },
+    { url = "https://files.pythonhosted.org/packages/07/fb/0cf61dc84b2b088391830f6274cb57c82e4da8bbc2efeac8c025edb88772/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3", size = 142742, upload-time = "2025-10-14T04:40:36.105Z" },
+    { url = "https://files.pythonhosted.org/packages/62/8b/171935adf2312cd745d290ed93cf16cf0dfe320863ab7cbeeae1dcd6535f/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc", size = 160863, upload-time = "2025-10-14T04:40:37.188Z" },
+    { url = "https://files.pythonhosted.org/packages/09/73/ad875b192bda14f2173bfc1bc9a55e009808484a4b256748d931b6948442/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897", size = 157837, upload-time = "2025-10-14T04:40:38.435Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/fc/de9cce525b2c5b94b47c70a4b4fb19f871b24995c728e957ee68ab1671ea/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381", size = 151550, upload-time = "2025-10-14T04:40:40.053Z" },
+    { url = "https://files.pythonhosted.org/packages/55/c2/43edd615fdfba8c6f2dfbd459b25a6b3b551f24ea21981e23fb768503ce1/charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815", size = 149162, upload-time = "2025-10-14T04:40:41.163Z" },
+    { url = "https://files.pythonhosted.org/packages/03/86/bde4ad8b4d0e9429a4e82c1e8f5c659993a9a863ad62c7df05cf7b678d75/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0", size = 150019, upload-time = "2025-10-14T04:40:42.276Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/86/a151eb2af293a7e7bac3a739b81072585ce36ccfb4493039f49f1d3cae8c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161", size = 143310, upload-time = "2025-10-14T04:40:43.439Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/fe/43dae6144a7e07b87478fdfc4dbe9efd5defb0e7ec29f5f58a55aeef7bf7/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4", size = 162022, upload-time = "2025-10-14T04:40:44.547Z" },
+    { url = "https://files.pythonhosted.org/packages/80/e6/7aab83774f5d2bca81f42ac58d04caf44f0cc2b65fc6db2b3b2e8a05f3b3/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89", size = 149383, upload-time = "2025-10-14T04:40:46.018Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/e8/b289173b4edae05c0dde07f69f8db476a0b511eac556dfe0d6bda3c43384/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569", size = 159098, upload-time = "2025-10-14T04:40:47.081Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/df/fe699727754cae3f8478493c7f45f777b17c3ef0600e28abfec8619eb49c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224", size = 152991, upload-time = "2025-10-14T04:40:48.246Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/86/584869fe4ddb6ffa3bd9f491b87a01568797fb9bd8933f557dba9771beaf/charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a", size = 99456, upload-time = "2025-10-14T04:40:49.376Z" },
+    { url = "https://files.pythonhosted.org/packages/65/f6/62fdd5feb60530f50f7e38b4f6a1d5203f4d16ff4f9f0952962c044e919a/charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016", size = 106978, upload-time = "2025-10-14T04:40:50.844Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/9d/0710916e6c82948b3be62d9d398cb4fcf4e97b56d6a6aeccd66c4b2f2bd5/charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1", size = 99969, upload-time = "2025-10-14T04:40:52.272Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" },
+    { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload-time = "2025-10-14T04:40:57.217Z" },
+    { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload-time = "2025-10-14T04:40:58.358Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload-time = "2025-10-14T04:40:59.468Z" },
+    { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload-time = "2025-10-14T04:41:00.623Z" },
+    { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload-time = "2025-10-14T04:41:01.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload-time = "2025-10-14T04:41:03.231Z" },
+    { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload-time = "2025-10-14T04:41:04.715Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload-time = "2025-10-14T04:41:05.827Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload-time = "2025-10-14T04:41:06.938Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload-time = "2025-10-14T04:41:08.101Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload-time = "2025-10-14T04:41:09.23Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload-time = "2025-10-14T04:41:10.467Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload-time = "2025-10-14T04:41:11.915Z" },
+    { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" },
+    { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" },
+    { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" },
+    { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" },
+    { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/46/61/de6cd827efad202d7057d93e0fed9294b96952e188f7384832791c7b2254/click-8.3.0.tar.gz", hash = "sha256:e7b8232224eba16f4ebe410c25ced9f7875cb5f3263ffc93cc3e8da705e229c4", size = 276943, upload-time = "2025-09-18T17:32:23.696Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/d3/9dcc0f5797f070ec8edf30fbadfb200e71d9db6b84d211e3b2085a7589a0/click-8.3.0-py3-none-any.whl", hash = "sha256:9b9f285302c6e3064f4330c05f05b81945b2a39544279343e6e7c5f27a9baddc", size = 107295, upload-time = "2025-09-18T17:32:22.42Z" },
+]
+
+[[package]]
+name = "cloudpickle"
+version = "3.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/52/39/069100b84d7418bc358d81669d5748efb14b9cceacd2f9c75f550424132f/cloudpickle-3.1.1.tar.gz", hash = "sha256:b216fa8ae4019d5482a8ac3c95d8f6346115d8835911fd4aefd1a445e4242c64", size = 22113, upload-time = "2025-01-14T17:02:05.085Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/e8/64c37fadfc2816a7701fa8a6ed8d87327c7d54eacfbfb6edab14a2f2be75/cloudpickle-3.1.1-py3-none-any.whl", hash = "sha256:c8c5a44295039331ee9dad40ba100a9c7297b6f988e50e87ccdf3765a668350e", size = 20992, upload-time = "2025-01-14T17:02:02.417Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "colorlog"
+version = "6.10.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a2/61/f083b5ac52e505dfc1c624eafbf8c7589a0d7f32daa398d2e7590efa5fda/colorlog-6.10.1.tar.gz", hash = "sha256:eb4ae5cb65fe7fec7773c2306061a8e63e02efc2c72eba9d27b0fa23c94f1321", size = 17162, upload-time = "2025-10-16T16:14:11.978Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6d/c1/e419ef3723a074172b68aaa89c9f3de486ed4c2399e2dbd8113a4fdcaf9e/colorlog-6.10.1-py3-none-any.whl", hash = "sha256:2d7e8348291948af66122cff006c9f8da6255d224e7cf8e37d8de2df3bad8c9c", size = 11743, upload-time = "2025-10-16T16:14:10.512Z" },
+]
+
+[[package]]
+name = "contourpy"
+version = "1.3.2"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/54/eb9bfc647b19f2009dd5c7f5ec51c4e6ca831725f1aea7a993034f483147/contourpy-1.3.2.tar.gz", hash = "sha256:b6945942715a034c671b7fc54f9588126b0b8bf23db2696e3ca8328f3ff0ab54", size = 13466130, upload-time = "2025-04-15T17:47:53.79Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/a3/da4153ec8fe25d263aa48c1a4cbde7f49b59af86f0b6f7862788c60da737/contourpy-1.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ba38e3f9f330af820c4b27ceb4b9c7feee5fe0493ea53a8720f4792667465934", size = 268551, upload-time = "2025-04-15T17:34:46.581Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/6c/330de89ae1087eb622bfca0177d32a7ece50c3ef07b28002de4757d9d875/contourpy-1.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dc41ba0714aa2968d1f8674ec97504a8f7e334f48eeacebcaa6256213acb0989", size = 253399, upload-time = "2025-04-15T17:34:51.427Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/bd/20c6726b1b7f81a8bee5271bed5c165f0a8e1f572578a9d27e2ccb763cb2/contourpy-1.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9be002b31c558d1ddf1b9b415b162c603405414bacd6932d031c5b5a8b757f0d", size = 312061, upload-time = "2025-04-15T17:34:55.961Z" },
+    { url = "https://files.pythonhosted.org/packages/22/fc/a9665c88f8a2473f823cf1ec601de9e5375050f1958cbb356cdf06ef1ab6/contourpy-1.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8d2e74acbcba3bfdb6d9d8384cdc4f9260cae86ed9beee8bd5f54fee49a430b9", size = 351956, upload-time = "2025-04-15T17:35:00.992Z" },
+    { url = "https://files.pythonhosted.org/packages/25/eb/9f0a0238f305ad8fb7ef42481020d6e20cf15e46be99a1fcf939546a177e/contourpy-1.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e259bced5549ac64410162adc973c5e2fb77f04df4a439d00b478e57a0e65512", size = 320872, upload-time = "2025-04-15T17:35:06.177Z" },
+    { url = "https://files.pythonhosted.org/packages/32/5c/1ee32d1c7956923202f00cf8d2a14a62ed7517bdc0ee1e55301227fc273c/contourpy-1.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad687a04bc802cbe8b9c399c07162a3c35e227e2daccf1668eb1f278cb698631", size = 325027, upload-time = "2025-04-15T17:35:11.244Z" },
+    { url = "https://files.pythonhosted.org/packages/83/bf/9baed89785ba743ef329c2b07fd0611d12bfecbedbdd3eeecf929d8d3b52/contourpy-1.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cdd22595308f53ef2f891040ab2b93d79192513ffccbd7fe19be7aa773a5e09f", size = 1306641, upload-time = "2025-04-15T17:35:26.701Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/cc/74e5e83d1e35de2d28bd97033426b450bc4fd96e092a1f7a63dc7369b55d/contourpy-1.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b4f54d6a2defe9f257327b0f243612dd051cc43825587520b1bf74a31e2f6ef2", size = 1374075, upload-time = "2025-04-15T17:35:43.204Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/42/17f3b798fd5e033b46a16f8d9fcb39f1aba051307f5ebf441bad1ecf78f8/contourpy-1.3.2-cp310-cp310-win32.whl", hash = "sha256:f939a054192ddc596e031e50bb13b657ce318cf13d264f095ce9db7dc6ae81c0", size = 177534, upload-time = "2025-04-15T17:35:46.554Z" },
+    { url = "https://files.pythonhosted.org/packages/54/ec/5162b8582f2c994721018d0c9ece9dc6ff769d298a8ac6b6a652c307e7df/contourpy-1.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:c440093bbc8fc21c637c03bafcbef95ccd963bc6e0514ad887932c18ca2a759a", size = 221188, upload-time = "2025-04-15T17:35:50.064Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/b9/ede788a0b56fc5b071639d06c33cb893f68b1178938f3425debebe2dab78/contourpy-1.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6a37a2fb93d4df3fc4c0e363ea4d16f83195fc09c891bc8ce072b9d084853445", size = 269636, upload-time = "2025-04-15T17:35:54.473Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/75/3469f011d64b8bbfa04f709bfc23e1dd71be54d05b1b083be9f5b22750d1/contourpy-1.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b7cd50c38f500bbcc9b6a46643a40e0913673f869315d8e70de0438817cb7773", size = 254636, upload-time = "2025-04-15T17:35:58.283Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/2f/95adb8dae08ce0ebca4fd8e7ad653159565d9739128b2d5977806656fcd2/contourpy-1.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d6658ccc7251a4433eebd89ed2672c2ed96fba367fd25ca9512aa92a4b46c4f1", size = 313053, upload-time = "2025-04-15T17:36:03.235Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/a6/8ccf97a50f31adfa36917707fe39c9a0cbc24b3bbb58185577f119736cc9/contourpy-1.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:70771a461aaeb335df14deb6c97439973d253ae70660ca085eec25241137ef43", size = 352985, upload-time = "2025-04-15T17:36:08.275Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/b6/7925ab9b77386143f39d9c3243fdd101621b4532eb126743201160ffa7e6/contourpy-1.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65a887a6e8c4cd0897507d814b14c54a8c2e2aa4ac9f7686292f9769fcf9a6ab", size = 323750, upload-time = "2025-04-15T17:36:13.29Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/f3/20c5d1ef4f4748e52d60771b8560cf00b69d5c6368b5c2e9311bcfa2a08b/contourpy-1.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3859783aefa2b8355697f16642695a5b9792e7a46ab86da1118a4a23a51a33d7", size = 326246, upload-time = "2025-04-15T17:36:18.329Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/e5/9dae809e7e0b2d9d70c52b3d24cba134dd3dad979eb3e5e71f5df22ed1f5/contourpy-1.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:eab0f6db315fa4d70f1d8ab514e527f0366ec021ff853d7ed6a2d33605cf4b83", size = 1308728, upload-time = "2025-04-15T17:36:33.878Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/4a/0058ba34aeea35c0b442ae61a4f4d4ca84d6df8f91309bc2d43bb8dd248f/contourpy-1.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d91a3ccc7fea94ca0acab82ceb77f396d50a1f67412efe4c526f5d20264e6ecd", size = 1375762, upload-time = "2025-04-15T17:36:51.295Z" },
+    { url = "https://files.pythonhosted.org/packages/09/33/7174bdfc8b7767ef2c08ed81244762d93d5c579336fc0b51ca57b33d1b80/contourpy-1.3.2-cp311-cp311-win32.whl", hash = "sha256:1c48188778d4d2f3d48e4643fb15d8608b1d01e4b4d6b0548d9b336c28fc9b6f", size = 178196, upload-time = "2025-04-15T17:36:55.002Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/fe/4029038b4e1c4485cef18e480b0e2cd2d755448bb071eb9977caac80b77b/contourpy-1.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:5ebac872ba09cb8f2131c46b8739a7ff71de28a24c869bcad554477eb089a878", size = 222017, upload-time = "2025-04-15T17:36:58.576Z" },
+    { url = "https://files.pythonhosted.org/packages/34/f7/44785876384eff370c251d58fd65f6ad7f39adce4a093c934d4a67a7c6b6/contourpy-1.3.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4caf2bcd2969402bf77edc4cb6034c7dd7c0803213b3523f111eb7460a51b8d2", size = 271580, upload-time = "2025-04-15T17:37:03.105Z" },
+    { url = "https://files.pythonhosted.org/packages/93/3b/0004767622a9826ea3d95f0e9d98cd8729015768075d61f9fea8eeca42a8/contourpy-1.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:82199cb78276249796419fe36b7386bd8d2cc3f28b3bc19fe2454fe2e26c4c15", size = 255530, upload-time = "2025-04-15T17:37:07.026Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/bb/7bd49e1f4fa805772d9fd130e0d375554ebc771ed7172f48dfcd4ca61549/contourpy-1.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:106fab697af11456fcba3e352ad50effe493a90f893fca6c2ca5c033820cea92", size = 307688, upload-time = "2025-04-15T17:37:11.481Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/97/e1d5dbbfa170725ef78357a9a0edc996b09ae4af170927ba8ce977e60a5f/contourpy-1.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d14f12932a8d620e307f715857107b1d1845cc44fdb5da2bc8e850f5ceba9f87", size = 347331, upload-time = "2025-04-15T17:37:18.212Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/66/e69e6e904f5ecf6901be3dd16e7e54d41b6ec6ae3405a535286d4418ffb4/contourpy-1.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:532fd26e715560721bb0d5fc7610fce279b3699b018600ab999d1be895b09415", size = 318963, upload-time = "2025-04-15T17:37:22.76Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/32/b8a1c8965e4f72482ff2d1ac2cd670ce0b542f203c8e1d34e7c3e6925da7/contourpy-1.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b383144cf2d2c29f01a1e8170f50dacf0eac02d64139dcd709a8ac4eb3cfe", size = 323681, upload-time = "2025-04-15T17:37:33.001Z" },
+    { url = "https://files.pythonhosted.org/packages/30/c6/12a7e6811d08757c7162a541ca4c5c6a34c0f4e98ef2b338791093518e40/contourpy-1.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c49f73e61f1f774650a55d221803b101d966ca0c5a2d6d5e4320ec3997489441", size = 1308674, upload-time = "2025-04-15T17:37:48.64Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/8a/bebe5a3f68b484d3a2b8ffaf84704b3e343ef1addea528132ef148e22b3b/contourpy-1.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3d80b2c0300583228ac98d0a927a1ba6a2ba6b8a742463c564f1d419ee5b211e", size = 1380480, upload-time = "2025-04-15T17:38:06.7Z" },
+    { url = "https://files.pythonhosted.org/packages/34/db/fcd325f19b5978fb509a7d55e06d99f5f856294c1991097534360b307cf1/contourpy-1.3.2-cp312-cp312-win32.whl", hash = "sha256:90df94c89a91b7362e1142cbee7568f86514412ab8a2c0d0fca72d7e91b62912", size = 178489, upload-time = "2025-04-15T17:38:10.338Z" },
+    { url = "https://files.pythonhosted.org/packages/01/c8/fadd0b92ffa7b5eb5949bf340a63a4a496a6930a6c37a7ba0f12acb076d6/contourpy-1.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:8c942a01d9163e2e5cfb05cb66110121b8d07ad438a17f9e766317bcb62abf73", size = 223042, upload-time = "2025-04-15T17:38:14.239Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/61/5673f7e364b31e4e7ef6f61a4b5121c5f170f941895912f773d95270f3a2/contourpy-1.3.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:de39db2604ae755316cb5967728f4bea92685884b1e767b7c24e983ef5f771cb", size = 271630, upload-time = "2025-04-15T17:38:19.142Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/66/a40badddd1223822c95798c55292844b7e871e50f6bfd9f158cb25e0bd39/contourpy-1.3.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3f9e896f447c5c8618f1edb2bafa9a4030f22a575ec418ad70611450720b5b08", size = 255670, upload-time = "2025-04-15T17:38:23.688Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/c7/cf9fdee8200805c9bc3b148f49cb9482a4e3ea2719e772602a425c9b09f8/contourpy-1.3.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71e2bd4a1c4188f5c2b8d274da78faab884b59df20df63c34f74aa1813c4427c", size = 306694, upload-time = "2025-04-15T17:38:28.238Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/e7/ccb9bec80e1ba121efbffad7f38021021cda5be87532ec16fd96533bb2e0/contourpy-1.3.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de425af81b6cea33101ae95ece1f696af39446db9682a0b56daaa48cfc29f38f", size = 345986, upload-time = "2025-04-15T17:38:33.502Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/49/ca13bb2da90391fa4219fdb23b078d6065ada886658ac7818e5441448b78/contourpy-1.3.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:977e98a0e0480d3fe292246417239d2d45435904afd6d7332d8455981c408b85", size = 318060, upload-time = "2025-04-15T17:38:38.672Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/65/5245ce8c548a8422236c13ffcdcdada6a2a812c361e9e0c70548bb40b661/contourpy-1.3.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:434f0adf84911c924519d2b08fc10491dd282b20bdd3fa8f60fd816ea0b48841", size = 322747, upload-time = "2025-04-15T17:38:43.712Z" },
+    { url = "https://files.pythonhosted.org/packages/72/30/669b8eb48e0a01c660ead3752a25b44fdb2e5ebc13a55782f639170772f9/contourpy-1.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c66c4906cdbc50e9cba65978823e6e00b45682eb09adbb78c9775b74eb222422", size = 1308895, upload-time = "2025-04-15T17:39:00.224Z" },
+    { url = "https://files.pythonhosted.org/packages/05/5a/b569f4250decee6e8d54498be7bdf29021a4c256e77fe8138c8319ef8eb3/contourpy-1.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8b7fc0cd78ba2f4695fd0a6ad81a19e7e3ab825c31b577f384aa9d7817dc3bef", size = 1379098, upload-time = "2025-04-15T17:43:29.649Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ba/b227c3886d120e60e41b28740ac3617b2f2b971b9f601c835661194579f1/contourpy-1.3.2-cp313-cp313-win32.whl", hash = "sha256:15ce6ab60957ca74cff444fe66d9045c1fd3e92c8936894ebd1f3eef2fff075f", size = 178535, upload-time = "2025-04-15T17:44:44.532Z" },
+    { url = "https://files.pythonhosted.org/packages/12/6e/2fed56cd47ca739b43e892707ae9a13790a486a3173be063681ca67d2262/contourpy-1.3.2-cp313-cp313-win_amd64.whl", hash = "sha256:e1578f7eafce927b168752ed7e22646dad6cd9bca673c60bff55889fa236ebf9", size = 223096, upload-time = "2025-04-15T17:44:48.194Z" },
+    { url = "https://files.pythonhosted.org/packages/54/4c/e76fe2a03014a7c767d79ea35c86a747e9325537a8b7627e0e5b3ba266b4/contourpy-1.3.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0475b1f6604896bc7c53bb070e355e9321e1bc0d381735421a2d2068ec56531f", size = 285090, upload-time = "2025-04-15T17:43:34.084Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/e2/5aba47debd55d668e00baf9651b721e7733975dc9fc27264a62b0dd26eb8/contourpy-1.3.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c85bb486e9be652314bb5b9e2e3b0d1b2e643d5eec4992c0fbe8ac71775da739", size = 268643, upload-time = "2025-04-15T17:43:38.626Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/37/cd45f1f051fe6230f751cc5cdd2728bb3a203f5619510ef11e732109593c/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:745b57db7758f3ffc05a10254edd3182a2a83402a89c00957a8e8a22f5582823", size = 310443, upload-time = "2025-04-15T17:43:44.522Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/a2/36ea6140c306c9ff6dd38e3bcec80b3b018474ef4d17eb68ceecd26675f4/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:970e9173dbd7eba9b4e01aab19215a48ee5dd3f43cef736eebde064a171f89a5", size = 349865, upload-time = "2025-04-15T17:43:49.545Z" },
+    { url = "https://files.pythonhosted.org/packages/95/b7/2fc76bc539693180488f7b6cc518da7acbbb9e3b931fd9280504128bf956/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c6c4639a9c22230276b7bffb6a850dfc8258a2521305e1faefe804d006b2e532", size = 321162, upload-time = "2025-04-15T17:43:54.203Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/10/76d4f778458b0aa83f96e59d65ece72a060bacb20cfbee46cf6cd5ceba41/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc829960f34ba36aad4302e78eabf3ef16a3a100863f0d4eeddf30e8a485a03b", size = 327355, upload-time = "2025-04-15T17:44:01.025Z" },
+    { url = "https://files.pythonhosted.org/packages/43/a3/10cf483ea683f9f8ab096c24bad3cce20e0d1dd9a4baa0e2093c1c962d9d/contourpy-1.3.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d32530b534e986374fc19eaa77fcb87e8a99e5431499949b828312bdcd20ac52", size = 1307935, upload-time = "2025-04-15T17:44:17.322Z" },
+    { url = "https://files.pythonhosted.org/packages/78/73/69dd9a024444489e22d86108e7b913f3528f56cfc312b5c5727a44188471/contourpy-1.3.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e298e7e70cf4eb179cc1077be1c725b5fd131ebc81181bf0c03525c8abc297fd", size = 1372168, upload-time = "2025-04-15T17:44:33.43Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/1b/96d586ccf1b1a9d2004dd519b25fbf104a11589abfd05484ff12199cca21/contourpy-1.3.2-cp313-cp313t-win32.whl", hash = "sha256:d0e589ae0d55204991450bb5c23f571c64fe43adaa53f93fc902a84c96f52fe1", size = 189550, upload-time = "2025-04-15T17:44:37.092Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/e6/6000d0094e8a5e32ad62591c8609e269febb6e4db83a1c75ff8868b42731/contourpy-1.3.2-cp313-cp313t-win_amd64.whl", hash = "sha256:78e9253c3de756b3f6a5174d024c4835acd59eb3f8e2ca13e775dbffe1558f69", size = 238214, upload-time = "2025-04-15T17:44:40.827Z" },
+    { url = "https://files.pythonhosted.org/packages/33/05/b26e3c6ecc05f349ee0013f0bb850a761016d89cec528a98193a48c34033/contourpy-1.3.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:fd93cc7f3139b6dd7aab2f26a90dde0aa9fc264dbf70f6740d498a70b860b82c", size = 265681, upload-time = "2025-04-15T17:44:59.314Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/25/ac07d6ad12affa7d1ffed11b77417d0a6308170f44ff20fa1d5aa6333f03/contourpy-1.3.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:107ba8a6a7eec58bb475329e6d3b95deba9440667c4d62b9b6063942b61d7f16", size = 315101, upload-time = "2025-04-15T17:45:04.165Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/4d/5bb3192bbe9d3f27e3061a6a8e7733c9120e203cb8515767d30973f71030/contourpy-1.3.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:ded1706ed0c1049224531b81128efbd5084598f18d8a2d9efae833edbd2b40ad", size = 220599, upload-time = "2025-04-15T17:45:08.456Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/c0/91f1215d0d9f9f343e4773ba6c9b89e8c0cc7a64a6263f21139da639d848/contourpy-1.3.2-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5f5964cdad279256c084b69c3f412b7801e15356b16efa9d78aa974041903da0", size = 266807, upload-time = "2025-04-15T17:45:15.535Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/79/6be7e90c955c0487e7712660d6cead01fa17bff98e0ea275737cc2bc8e71/contourpy-1.3.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49b65a95d642d4efa8f64ba12558fcb83407e58a2dfba9d796d77b63ccfcaff5", size = 318729, upload-time = "2025-04-15T17:45:20.166Z" },
+    { url = "https://files.pythonhosted.org/packages/87/68/7f46fb537958e87427d98a4074bcde4b67a70b04900cfc5ce29bc2f556c1/contourpy-1.3.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:8c5acb8dddb0752bf252e01a3035b21443158910ac16a3b0d20e7fed7d534ce5", size = 221791, upload-time = "2025-04-15T17:45:24.794Z" },
+]
+
+[[package]]
+name = "contourpy"
+version = "1.3.3"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+dependencies = [
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/91/2e/c4390a31919d8a78b90e8ecf87cd4b4c4f05a5b48d05ec17db8e5404c6f4/contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1", size = 288773, upload-time = "2025-07-26T12:01:02.277Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/44/c4b0b6095fef4dc9c420e041799591e3b63e9619e3044f7f4f6c21c0ab24/contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381", size = 270149, upload-time = "2025-07-26T12:01:04.072Z" },
+    { url = "https://files.pythonhosted.org/packages/30/2e/dd4ced42fefac8470661d7cb7e264808425e6c5d56d175291e93890cce09/contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7", size = 329222, upload-time = "2025-07-26T12:01:05.688Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/74/cc6ec2548e3d276c71389ea4802a774b7aa3558223b7bade3f25787fafc2/contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1", size = 377234, upload-time = "2025-07-26T12:01:07.054Z" },
+    { url = "https://files.pythonhosted.org/packages/03/b3/64ef723029f917410f75c09da54254c5f9ea90ef89b143ccadb09df14c15/contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a", size = 380555, upload-time = "2025-07-26T12:01:08.801Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/4b/6157f24ca425b89fe2eb7e7be642375711ab671135be21e6faa100f7448c/contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db", size = 355238, upload-time = "2025-07-26T12:01:10.319Z" },
+    { url = "https://files.pythonhosted.org/packages/98/56/f914f0dd678480708a04cfd2206e7c382533249bc5001eb9f58aa693e200/contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620", size = 1326218, upload-time = "2025-07-26T12:01:12.659Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/d7/4a972334a0c971acd5172389671113ae82aa7527073980c38d5868ff1161/contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f", size = 1392867, upload-time = "2025-07-26T12:01:15.533Z" },
+    { url = "https://files.pythonhosted.org/packages/75/3e/f2cc6cd56dc8cff46b1a56232eabc6feea52720083ea71ab15523daab796/contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff", size = 183677, upload-time = "2025-07-26T12:01:17.088Z" },
+    { url = "https://files.pythonhosted.org/packages/98/4b/9bd370b004b5c9d8045c6c33cf65bae018b27aca550a3f657cdc99acdbd8/contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42", size = 225234, upload-time = "2025-07-26T12:01:18.256Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/b6/71771e02c2e004450c12b1120a5f488cad2e4d5b590b1af8bad060360fe4/contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470", size = 193123, upload-time = "2025-07-26T12:01:19.848Z" },
+    { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" },
+    { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" },
+    { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" },
+    { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" },
+    { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" },
+    { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" },
+    { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" },
+    { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" },
+    { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" },
+    { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" },
+    { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" },
+    { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" },
+    { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" },
+    { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" },
+    { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" },
+    { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/29/8dcfe16f0107943fa92388c23f6e05cff0ba58058c4c95b00280d4c75a14/contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497", size = 278809, upload-time = "2025-07-26T12:02:52.74Z" },
+    { url = "https://files.pythonhosted.org/packages/85/a9/8b37ef4f7dafeb335daee3c8254645ef5725be4d9c6aa70b50ec46ef2f7e/contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8", size = 261593, upload-time = "2025-07-26T12:02:54.037Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/59/ebfb8c677c75605cc27f7122c90313fd2f375ff3c8d19a1694bda74aaa63/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e", size = 302202, upload-time = "2025-07-26T12:02:55.947Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/37/21972a15834d90bfbfb009b9d004779bd5a07a0ec0234e5ba8f64d5736f4/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989", size = 329207, upload-time = "2025-07-26T12:02:57.468Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/58/bd257695f39d05594ca4ad60df5bcb7e32247f9951fd09a9b8edb82d1daa/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77", size = 225315, upload-time = "2025-07-26T12:02:58.801Z" },
+]
+
+[[package]]
+name = "cryptography"
+version = "50.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/de/41/6cbdcf9142d00fe82836fbb51e503e58088575cf7a0fe1dbff6695bf0840/cryptography-50.0.0.tar.gz", hash = "sha256:eeac2acb5a20ed25e0ad6d1df9891a520b78b404266b6d11778f25d5d691a6c9", size = 880201, upload-time = "2026-07-31T14:25:10.11Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c5/5c/59086b4aac5e879d38ddbcf74e4be7ade89cebc3eb199a55da998c3bb46a/cryptography-50.0.0-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:031e2d5dd4bb9caa3ca9c82e5a197fd8ae680232cee62603d1a813f3f07e3d03", size = 4001252, upload-time = "2026-07-31T14:23:33.331Z" },
+    { url = "https://files.pythonhosted.org/packages/57/ef/8f2df13c7216bcad3e1c74e07f6e193d93e998e114f524a53877c9af27ad/cryptography-50.0.0-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fd9192b7b70c573d7f214eb1ae35e00d359f6f5e4b27c7e21e30de1fc6204645", size = 4719554, upload-time = "2026-07-31T14:23:35.611Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/41/029086c34d91052fc3b88bcc8056f709a7c915c7a23b235a54eb800b1c97/cryptography-50.0.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:06a32a980526a6ab9a4b9bf8f7385800791e2bb960903cb6b530e4817509a3b7", size = 4702130, upload-time = "2026-07-31T14:23:37.635Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/ff/b6ce0954962e7f7b969f850a883744197bb3910bdfd7b6da162eab7d9f68/cryptography-50.0.0-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:a1b30560f2acc95aa8b2e06e716a13dbfc97314747b80d9707e307f77b40d6b3", size = 4725244, upload-time = "2026-07-31T14:23:39.471Z" },
+    { url = "https://files.pythonhosted.org/packages/06/1e/63a1027cb7fec360a182208e1b7767d5aa1fe57be3d6aa856e69a321edc0/cryptography-50.0.0-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:8d89f3976b10b4ce31118de72329025f70d2c6ead14a8217c5514dd2c6d5a78f", size = 5342265, upload-time = "2026-07-31T14:23:41.286Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/72/a1116d683a6d7ece94590013882515de087edf9ef0e6292aae615a44df73/cryptography-50.0.0-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:b42a28c1844fd9de8f3f7d540e36b66f3a9c83fceac7170ebc7a6a19edd9dcae", size = 4734609, upload-time = "2026-07-31T14:23:43.139Z" },
+    { url = "https://files.pythonhosted.org/packages/15/37/36a9c479bbe49acea2636c7fd3360d20f7b7e079c300352011c44850b181/cryptography-50.0.0-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:900131fafd8aead39ac7dd3a7e833be754c17a95cfd91221636949fe4eb0aa8a", size = 4356517, upload-time = "2026-07-31T14:23:44.939Z" },
+    { url = "https://files.pythonhosted.org/packages/32/98/8a151d64367204cbc63ec65d37502f1d9c53cf4bfc6ec3c532614dbec60d/cryptography-50.0.0-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:07949c449a1abcf60d1ee6e88956d89404c7df3c8258f46589e912988e551987", size = 4724529, upload-time = "2026-07-31T14:23:46.93Z" },
+    { url = "https://files.pythonhosted.org/packages/22/f6/ec13b470172126464a86bf54d2294a46d29837fc51ba3e45d4047946fb5e/cryptography-50.0.0-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:f89831ef99dd7dd169ab06d63a831adb9e20a87aac6d380266bbda5823349169", size = 5299852, upload-time = "2026-07-31T14:23:48.851Z" },
+    { url = "https://files.pythonhosted.org/packages/da/3a/f05e32c99d440c9bb891ea0e36c9091891e36be5a9a87ab2ee6ea20729f6/cryptography-50.0.0-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:82148ec5bddac30b51a5b3c1945075f896fa022cb93f8e4a01e9f6ee95292c5f", size = 4734462, upload-time = "2026-07-31T14:23:50.861Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/dc/bd72b26be8953f80625f63151efd38eee71c76ca6cf591c08ff34615a79e/cryptography-50.0.0-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1489e263a8048bb8b6a8bac662eb2d402ea5d2b7b4699b72f385f1e2772db105", size = 4852708, upload-time = "2026-07-31T14:23:52.715Z" },
+    { url = "https://files.pythonhosted.org/packages/27/20/c930314a2ab476d15dec966ec87e2e9637bb02b06106b12c0396c57bb603/cryptography-50.0.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:7cec5b856506da6defb290f30c9ee687d5f5e8cb0bd3f6459dde43b0b4fa40ef", size = 5004179, upload-time = "2026-07-31T14:23:54.887Z" },
+    { url = "https://files.pythonhosted.org/packages/32/2e/c9db68a0c4bfa28e310707527c0ee3a2bd254104d2e02e68f368e197aa4c/cryptography-50.0.0-cp311-abi3-win_amd64.whl", hash = "sha256:bd1c592e4d5974f0d08d4888e432157adba757c66da0246918e43677fafa2d30", size = 3840395, upload-time = "2026-07-31T14:23:56.677Z" },
+    { url = "https://files.pythonhosted.org/packages/03/37/73d005be173aff344af30e9fd2a576575cb2391a7101d9cd3842e1fa8cce/cryptography-50.0.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:ccdc4a71a4dabae05de219404f9f4abc38e3b58422177ff93d0da05967dafa07", size = 4036009, upload-time = "2026-07-31T14:24:24.122Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/c6/7a6202a534e32103a285b7834a120869557fe198d51d7cfe59754c8bda9c/cryptography-50.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:910e1d2668e7de9648f2bcee30e180db2a6b15c30f887d7c4c93ddf96e3992e3", size = 4745252, upload-time = "2026-07-31T14:24:26.118Z" },
+    { url = "https://files.pythonhosted.org/packages/85/4f/0fa8c2f4428198f15d9ff8d63400e27afbf94ce833f6108da1eb3753f945/cryptography-50.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a91296cb61e8df6f86d0c19cc4068228da256bf59bf86049fbd821084565327f", size = 4728939, upload-time = "2026-07-31T14:24:27.994Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/63/54dd723490ba2dc09b299682c10b38db38f159728bcaae8c591b8af2f22d/cryptography-50.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:e722f16708d854fe924790e051061f6704a472c3bac347b6fd88033ea8dd0dc5", size = 4748483, upload-time = "2026-07-31T14:24:30.254Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/dd/7c77d26285cc7f6991efce64a0f5b4f9383bfa5dd8c5033003eaf7db4cdb/cryptography-50.0.0-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:d764dcf130c428ef66786f866dd750f53182bc608813489915e9fc106bb0c82f", size = 5367599, upload-time = "2026-07-31T14:24:32.457Z" },
+    { url = "https://files.pythonhosted.org/packages/46/c9/f60aed34c013f317f92817b6c171c2d22a78270fa41109bd4b08af26b194/cryptography-50.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:105110f43a471dbd0060b9c9516cb8a6a79233631a04cc2ba16f28323ac6e025", size = 4762647, upload-time = "2026-07-31T14:24:34.599Z" },
+    { url = "https://files.pythonhosted.org/packages/be/f3/f9a0173b139372c3a48ed98154b45cc6b9de17c789d5ab552e621c293609/cryptography-50.0.0-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:828743d939e9629bc267b8e2d08d8bb67cd4319c771a33d4b18b22dd8fb7440a", size = 4385197, upload-time = "2026-07-31T14:24:36.647Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/36/83bb81f6e569bc38e1e4a7bc80f29b46bb9601920bc455fc8e888f5d5742/cryptography-50.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:2a8183b489dc1f7f80f135780fadc1108f14b31b8a40411c7a5b17425f65f28b", size = 4748095, upload-time = "2026-07-31T14:24:39.493Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/16/d3008eff98c764979865834c3d386d4fd041b5f52e7f34fc29ac1a5eb515/cryptography-50.0.0-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:6e7d61120573a7f2cd94cc095f9e81f6967c61ccdf194285aa143ecec8e0b708", size = 5325948, upload-time = "2026-07-31T14:24:41.556Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/f8/d97f9603efda3888187bfdb893f26c41be4735c10631d05d284ee6b047c4/cryptography-50.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:37fdb0d0111f1e2ff07139dfb79f1b49531f8e213c46f1163dd7642979b58c47", size = 4762400, upload-time = "2026-07-31T14:24:43.636Z" },
+    { url = "https://files.pythonhosted.org/packages/64/a2/4615c8f7d81a00b1d6e6afe19f694e1543582349fb5f4076f6cb5dc36485/cryptography-50.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c87f62a3d3b9888ed0fdde100ec06aa61ca9cd44bad9057d1dff9a516b5f5bb9", size = 4878208, upload-time = "2026-07-31T14:24:45.522Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/1a/efcfb02f91407149a0dacffffab791f7e19bf6385f63b3666dc8b5e5c9c8/cryptography-50.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:65c2c3add92b45fd0709db8594536aea39c2a67af0e27ffcf049c498501140b7", size = 5037050, upload-time = "2026-07-31T14:24:47.697Z" },
+    { url = "https://files.pythonhosted.org/packages/57/30/4a22984d4f1bdfb8c054f07a92bc176b97a3134cc1d6c4b3bffb1f3688b4/cryptography-50.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:d24fead1d4d076e1bfb006dcec392074a3cd8d7b4fc8a595aa64073b2b7a96ba", size = 3874135, upload-time = "2026-07-31T14:24:50.085Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/3e/e54cde8c01631a5a8226ccd617eab9e57fd5cfdad90f1a9e6bb570794631/cryptography-50.0.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:5e34edd123674534acd70147f0ca331eaa2c74e6325fb2028c886aa26ba0b68c", size = 3963170, upload-time = "2026-07-31T14:24:51.968Z" },
+    { url = "https://files.pythonhosted.org/packages/01/b6/0b9e125e90f3d2dcf599a218a899cda7326a3158cfa258723f0b398b08f6/cryptography-50.0.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:8eb5e1172eb569ea8a872796576e6a67c276351728b6455d5beb01242b027c6a", size = 4692441, upload-time = "2026-07-31T14:24:53.743Z" },
+    { url = "https://files.pythonhosted.org/packages/53/c9/a5151588710785a96d7bc4de27d4cd62f263bbbcb203cfe29df537eb6505/cryptography-50.0.0-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:910d11e1a385c654bf738bf3e6b8e6ed5de0f5610fcae2be9e5b398d8081d20e", size = 4699810, upload-time = "2026-07-31T14:24:55.746Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/1a/15b92b25eb6ce3089cd49377ae990a0f3ad485a510f968aed1f19dbdcdf2/cryptography-50.0.0-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:62598a8a57f815db4c6259a4e97d857dab56697e7de8e8ab02352ab74da1995d", size = 4691924, upload-time = "2026-07-31T14:24:58.082Z" },
+    { url = "https://files.pythonhosted.org/packages/62/15/219075012ab13e8905f3cd572204f4acb4b111df787104346b9bc0cea789/cryptography-50.0.0-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:07479a1cb08219ab719147e742e76090c9c773321959bb94946fffdd397a6437", size = 4699593, upload-time = "2026-07-31T14:24:59.951Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/b5/c2c5fce26f0ee40d21bafe7f191d29a34b35a65ac4fe8a1191d1983612e9/cryptography-50.0.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c99c003e088647b8a5b7c145d6f78c335f6348332b62e142d411c4b63d1460b9", size = 3813796, upload-time = "2026-07-31T14:25:02.298Z" },
+]
+
+[[package]]
+name = "cycler"
+version = "0.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" },
+]
+
+[[package]]
+name = "decorator"
+version = "5.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" },
+]
+
+[[package]]
+name = "deprecated"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/49/85/12f0a49a7c4ffb70572b6c2ef13c90c88fd190debda93b23f026b25f9634/deprecated-1.3.1.tar.gz", hash = "sha256:b1b50e0ff0c1fddaa5708a2c6b0a6588bb09b892825ab2b214ac9ea9d92a5223", size = 2932523, upload-time = "2025-10-30T08:19:02.757Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/d0/205d54408c08b13550c733c4b85429e7ead111c7f0014309637425520a9a/deprecated-1.3.1-py2.py3-none-any.whl", hash = "sha256:597bfef186b6f60181535a29fbe44865ce137a5079f295b479886c82729d5f3f", size = 11298, upload-time = "2025-10-30T08:19:00.758Z" },
+]
+
+[[package]]
+name = "distlib"
+version = "0.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/8e/709914eb2b5749865801041647dc7f4e6d00b549cfe88b65ca192995f07c/distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d", size = 614605, upload-time = "2025-07-17T16:52:00.465Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" },
+]
+
+[[package]]
+name = "docstring-parser"
+version = "0.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b2/9d/c3b43da9515bd270df0f80548d9944e389870713cc1fe2b8fb35fe2bcefd/docstring_parser-0.17.0.tar.gz", hash = "sha256:583de4a309722b3315439bb31d64ba3eebada841f2e2cee23b99df001434c912", size = 27442, upload-time = "2025-07-21T07:35:01.868Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/55/e2/2537ebcff11c1ee1ff17d8d0b6f4db75873e3b0fb32c2d4a2ee31ecb310a/docstring_parser-0.17.0-py3-none-any.whl", hash = "sha256:cf2569abd23dce8099b300f9b4fa8191e9582dda731fd533daf54c4551658708", size = 36896, upload-time = "2025-07-21T07:35:00.684Z" },
+]
+
+[[package]]
+name = "docutils"
+version = "0.21.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ae/ed/aefcc8cd0ba62a0560c3c18c33925362d46c6075480bfa4df87b28e169a9/docutils-0.21.2.tar.gz", hash = "sha256:3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f", size = 2204444, upload-time = "2024-04-23T18:57:18.24Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/d7/9322c609343d929e75e7e5e6255e614fcc67572cfd083959cdef3b7aad79/docutils-0.21.2-py3-none-any.whl", hash = "sha256:dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2", size = 587408, upload-time = "2024-04-23T18:57:14.835Z" },
+]
+
+[[package]]
+name = "embreex"
+version = "2.17.7.post6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and platform_machine != 'arm64' and platform_machine != 's390x') or (python_full_version < '3.11' and platform_machine != 's390x' and sys_platform != 'darwin') or (python_full_version >= '3.11' and platform_machine != 'arm64' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (python_full_version >= '3.11' and sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (platform_machine == 'arm64' and sys_platform == 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (platform_machine == 's390x' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.11.*' and platform_machine != 'arm64' and platform_machine != 's390x') or (python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'darwin') or (python_full_version != '3.11.*' and platform_machine != 'arm64' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (python_full_version != '3.11.*' and sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (platform_machine == 'arm64' and sys_platform == 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (platform_machine == 's390x' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.12' and platform_machine != 'arm64' and platform_machine != 's390x') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin') or (python_full_version < '3.12' and platform_machine != 'arm64' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (python_full_version < '3.12' and sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (platform_machine == 'arm64' and sys_platform == 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (platform_machine == 's390x' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cd/95/e22d50ef1624bb2edd0c0aab5e6415c58e2ddba411e3ae0a025766739d83/embreex-2.17.7.post6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:feb66dd5f79a6b6451cebe5192fea1858c7d97c537f02659f22b42d027352517", size = 10740295, upload-time = "2025-01-21T20:46:38.534Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d2/3e50e549b94752406adc6d11044716528d85e911b26f87fd70bb492dcb8a/embreex-2.17.7.post6-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:bb3887e1849e9b271a5b0c14457d68302897b6524a0695162d31e7d374d191fe", size = 17143857, upload-time = "2025-01-21T20:46:42.014Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/5e/33f94931d3ed0102f9cb9e0f0a57b0fc3571adc567f594f4141fd3e126ae/embreex-2.17.7.post6-cp310-cp310-win_amd64.whl", hash = "sha256:0cc92d58a864ae9536044c2e13e18765be4815ed29b62d6b047b76668c88c83c", size = 13468584, upload-time = "2025-01-21T20:46:47.7Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/36/dc4706b53cf84d1d472ce2cc60757b2b2353797c2b9b957bf5c05897e612/embreex-2.17.7.post6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8bae50c13a93d59aa77ca047faebe59e6a434cfeef6f12267c75ba4900433dbf", size = 10739983, upload-time = "2025-01-21T20:46:52.157Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/79/886c067554f5471cb0856a6ff65e9eb443ffcc9d34d202826c5e264fca23/embreex-2.17.7.post6-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:8b2e6605c8c6b3edb857f65ae7401983a0a606a34ac9af037ff31230fb7450d3", size = 17181681, upload-time = "2025-01-21T20:46:55.903Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/69/92030edc7e9166fadb3844f28950d46a2495ab93d12db21e92265f25fa0c/embreex-2.17.7.post6-cp311-cp311-win_amd64.whl", hash = "sha256:d74599143d404a307fe8fde206e90a567d3e981208c7853c5760429aac2d3c04", size = 13469149, upload-time = "2025-01-21T20:46:59.349Z" },
+    { url = "https://files.pythonhosted.org/packages/12/a4/b70a1e7b4d15c4cc249f6ac6f39dd78b9bb086b6725f7f6e6d74526e7ad8/embreex-2.17.7.post6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c3918bc208b580b41f881b6c398862f9508187ba45f2c8477d80d5a40d004f07", size = 10737865, upload-time = "2025-01-21T20:47:03.821Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/80/d7ee20576130473e1c9bc1f8acb149743f2bcd77fc601fb9a0a13daa14c8/embreex-2.17.7.post6-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:d0299f2a30018e0a1a352741a8df30dfe8f1cc8ae04d466dc72c6b8643190e77", size = 17213187, upload-time = "2025-01-21T20:47:07.989Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/ee/fcf521ac3c68accfe73a15866b8f64d982feba6dd83ac7135feac161e2a0/embreex-2.17.7.post6-cp312-cp312-win_amd64.whl", hash = "sha256:d090255ebfc1a49e528b33cdd1c39aed37ac792faaabf98407477a4d968dbb1e", size = 13468367, upload-time = "2025-01-21T20:47:13.303Z" },
+    { url = "https://files.pythonhosted.org/packages/99/d6/aa06d1060e6526f57d0920ccc5554d83de7dc5cd07d1ea4f2be53b40bc05/embreex-2.17.7.post6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b0331dbded79b878e9aaa30838de992370a3dca9597329bbe45cd697ac5c55de", size = 10734369, upload-time = "2025-01-21T20:47:18.175Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/d7/11e00e53ef9fb475ee80a9327af61a491d9f4ec10356be4a23dd6ff4ee47/embreex-2.17.7.post6-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:845dcee445e9be19d52a0c0672a36d4b3180b6e71ae33644545df34aaaf37894", size = 17194628, upload-time = "2025-01-21T20:47:21.609Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/40/7d8cf531bdff6acefe9cecf638ea6a2ccc3222cacde50902d692354be801/embreex-2.17.7.post6-cp313-cp313-win_amd64.whl", hash = "sha256:c3690a0e590f8ee60076e083fbc191567f7f21996e08d544622fdf15b015a0c1", size = 13465435, upload-time = "2025-01-21T20:47:25.005Z" },
+]
+
+[[package]]
+name = "etils"
+version = "1.13.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9b/a0/522bbff0f3cdd37968f90dd7f26c7aa801ed87f5ba335f156de7f2b88a48/etils-1.13.0.tar.gz", hash = "sha256:a5b60c71f95bcd2d43d4e9fb3dc3879120c1f60472bb5ce19f7a860b1d44f607", size = 106368, upload-time = "2025-07-15T10:29:10.563Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/98/87b5946356095738cb90a6df7b35ff69ac5750f6e783d5fbcc5cb3b6cbd7/etils-1.13.0-py3-none-any.whl", hash = "sha256:d9cd4f40fbe77ad6613b7348a18132cc511237b6c076dbb89105c0b520a4c6bb", size = 170603, upload-time = "2025-07-15T10:29:09.076Z" },
+]
+
+[package.optional-dependencies]
+epath = [
+    { name = "fsspec" },
+    { name = "importlib-resources" },
+    { name = "typing-extensions" },
+    { name = "zipp" },
+]
+
+[[package]]
+name = "exceptiongroup"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0b/9f/a65090624ecf468cdca03533906e7c69ed7588582240cfe7cc9e770b50eb/exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88", size = 29749, upload-time = "2025-05-10T17:42:51.123Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/36/f4/c6e662dade71f56cd2f3735141b265c3c79293c109549c1e6933b0651ffc/exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10", size = 16674, upload-time = "2025-05-10T17:42:49.33Z" },
+]
+
+[[package]]
+name = "executing"
+version = "2.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" },
+]
+
+[[package]]
+name = "fabric"
+version = "3.2.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "decorator" },
+    { name = "deprecated" },
+    { name = "invoke" },
+    { name = "paramiko" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0d/3f/337f278b70ba339c618a490f6b8033b7006c583bd197a897f12fbc468c51/fabric-3.2.2.tar.gz", hash = "sha256:8783ca42e3b0076f08b26901aac6b9d9b1f19c410074e7accfab902c184ff4a3", size = 183215, upload-time = "2023-08-31T01:42:05.55Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d6/1f/e99e23ee01847147fa194e8d41cfcf2535a2dbfcb51414c541cadb15c5d7/fabric-3.2.2-py3-none-any.whl", hash = "sha256:91c47c0be68b14936c88b34da8a1f55e5710fd28397dac5d4ff2e21558113a6f", size = 59417, upload-time = "2023-08-31T01:42:03.917Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "3.25.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/b8/00651a0f559862f3bb7d6f7477b192afe3f583cc5e26403b44e59a55ab34/filelock-3.25.2.tar.gz", hash = "sha256:b64ece2b38f4ca29dd3e810287aa8c48182bbecd1ae6e9ae126c9b35f1382694", size = 40480, upload-time = "2026-03-11T20:45:38.487Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/a5/842ae8f0c08b61d6484b52f99a03510a3a72d23141942d216ebe81fefbce/filelock-3.25.2-py3-none-any.whl", hash = "sha256:ca8afb0da15f229774c9ad1b455ed96e85a81373065fb10446672f64444ddf70", size = 26759, upload-time = "2026-03-11T20:45:37.437Z" },
+]
+
+[[package]]
+name = "flatbuffers"
+version = "25.12.19"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/2d/d2a548598be01649e2d46231d151a6c56d10b964d94043a335ae56ea2d92/flatbuffers-25.12.19-py2.py3-none-any.whl", hash = "sha256:7634f50c427838bb021c2d66a3d1168e9d199b0607e6329399f04846d42e20b4", size = 26661, upload-time = "2025-12-19T23:16:13.622Z" },
+]
+
+[[package]]
+name = "fonttools"
+version = "4.61.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/ca/cf17b88a8df95691275a3d77dc0a5ad9907f328ae53acbe6795da1b2f5ed/fonttools-4.61.1.tar.gz", hash = "sha256:6675329885c44657f826ef01d9e4fb33b9158e9d93c537d84ad8399539bc6f69", size = 3565756, upload-time = "2025-12-12T17:31:24.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5b/94/8a28707adb00bed1bf22dac16ccafe60faf2ade353dcb32c3617ee917307/fonttools-4.61.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7c7db70d57e5e1089a274cbb2b1fd635c9a24de809a231b154965d415d6c6d24", size = 2854799, upload-time = "2025-12-12T17:29:27.5Z" },
+    { url = "https://files.pythonhosted.org/packages/94/93/c2e682faaa5ee92034818d8f8a8145ae73eb83619600495dcf8503fa7771/fonttools-4.61.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5fe9fd43882620017add5eabb781ebfbc6998ee49b35bd7f8f79af1f9f99a958", size = 2403032, upload-time = "2025-12-12T17:29:30.115Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/62/1748f7e7e1ee41aa52279fd2e3a6d0733dc42a673b16932bad8e5d0c8b28/fonttools-4.61.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8db08051fc9e7d8bc622f2112511b8107d8f27cd89e2f64ec45e9825e8288da", size = 4897863, upload-time = "2025-12-12T17:29:32.535Z" },
+    { url = "https://files.pythonhosted.org/packages/69/69/4ca02ee367d2c98edcaeb83fc278d20972502ee071214ad9d8ca85e06080/fonttools-4.61.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a76d4cb80f41ba94a6691264be76435e5f72f2cb3cab0b092a6212855f71c2f6", size = 4859076, upload-time = "2025-12-12T17:29:34.907Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/f5/660f9e3cefa078861a7f099107c6d203b568a6227eef163dd173bfc56bdc/fonttools-4.61.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a13fc8aeb24bad755eea8f7f9d409438eb94e82cf86b08fe77a03fbc8f6a96b1", size = 4875623, upload-time = "2025-12-12T17:29:37.33Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d1/9d7c5091d2276ed47795c131c1bf9316c3c1ab2789c22e2f59e0572ccd38/fonttools-4.61.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b846a1fcf8beadeb9ea4f44ec5bdde393e2f1569e17d700bfc49cd69bde75881", size = 4993327, upload-time = "2025-12-12T17:29:39.781Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/2d/28def73837885ae32260d07660a052b99f0aa00454867d33745dfe49dbf0/fonttools-4.61.1-cp310-cp310-win32.whl", hash = "sha256:78a7d3ab09dc47ac1a363a493e6112d8cabed7ba7caad5f54dbe2f08676d1b47", size = 1502180, upload-time = "2025-12-12T17:29:42.217Z" },
+    { url = "https://files.pythonhosted.org/packages/63/fa/bfdc98abb4dd2bd491033e85e3ba69a2313c850e759a6daa014bc9433b0f/fonttools-4.61.1-cp310-cp310-win_amd64.whl", hash = "sha256:eff1ac3cc66c2ac7cda1e64b4e2f3ffef474b7335f92fc3833fc632d595fcee6", size = 1550654, upload-time = "2025-12-12T17:29:44.564Z" },
+    { url = "https://files.pythonhosted.org/packages/69/12/bf9f4eaa2fad039356cc627587e30ed008c03f1cebd3034376b5ee8d1d44/fonttools-4.61.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c6604b735bb12fef8e0efd5578c9fb5d3d8532d5001ea13a19cddf295673ee09", size = 2852213, upload-time = "2025-12-12T17:29:46.675Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/49/4138d1acb6261499bedde1c07f8c2605d1d8f9d77a151e5507fd3ef084b6/fonttools-4.61.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5ce02f38a754f207f2f06557523cd39a06438ba3aafc0639c477ac409fc64e37", size = 2401689, upload-time = "2025-12-12T17:29:48.769Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/fe/e6ce0fe20a40e03aef906af60aa87668696f9e4802fa283627d0b5ed777f/fonttools-4.61.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77efb033d8d7ff233385f30c62c7c79271c8885d5c9657d967ede124671bbdfb", size = 5058809, upload-time = "2025-12-12T17:29:51.701Z" },
+    { url = "https://files.pythonhosted.org/packages/79/61/1ca198af22f7dd22c17ab86e9024ed3c06299cfdb08170640e9996d501a0/fonttools-4.61.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:75c1a6dfac6abd407634420c93864a1e274ebc1c7531346d9254c0d8f6ca00f9", size = 5036039, upload-time = "2025-12-12T17:29:53.659Z" },
+    { url = "https://files.pythonhosted.org/packages/99/cc/fa1801e408586b5fce4da9f5455af8d770f4fc57391cd5da7256bb364d38/fonttools-4.61.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0de30bfe7745c0d1ffa2b0b7048fb7123ad0d71107e10ee090fa0b16b9452e87", size = 5034714, upload-time = "2025-12-12T17:29:55.592Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/aa/b7aeafe65adb1b0a925f8f25725e09f078c635bc22754f3fecb7456955b0/fonttools-4.61.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:58b0ee0ab5b1fc9921eccfe11d1435added19d6494dde14e323f25ad2bc30c56", size = 5158648, upload-time = "2025-12-12T17:29:57.861Z" },
+    { url = "https://files.pythonhosted.org/packages/99/f9/08ea7a38663328881384c6e7777bbefc46fd7d282adfd87a7d2b84ec9d50/fonttools-4.61.1-cp311-cp311-win32.whl", hash = "sha256:f79b168428351d11e10c5aeb61a74e1851ec221081299f4cf56036a95431c43a", size = 2280681, upload-time = "2025-12-12T17:29:59.943Z" },
+    { url = "https://files.pythonhosted.org/packages/07/ad/37dd1ae5fa6e01612a1fbb954f0927681f282925a86e86198ccd7b15d515/fonttools-4.61.1-cp311-cp311-win_amd64.whl", hash = "sha256:fe2efccb324948a11dd09d22136fe2ac8a97d6c1347cf0b58a911dcd529f66b7", size = 2331951, upload-time = "2025-12-12T17:30:02.254Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/16/7decaa24a1bd3a70c607b2e29f0adc6159f36a7e40eaba59846414765fd4/fonttools-4.61.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f3cb4a569029b9f291f88aafc927dd53683757e640081ca8c412781ea144565e", size = 2851593, upload-time = "2025-12-12T17:30:04.225Z" },
+    { url = "https://files.pythonhosted.org/packages/94/98/3c4cb97c64713a8cf499b3245c3bf9a2b8fd16a3e375feff2aed78f96259/fonttools-4.61.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41a7170d042e8c0024703ed13b71893519a1a6d6e18e933e3ec7507a2c26a4b2", size = 2400231, upload-time = "2025-12-12T17:30:06.47Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/37/82dbef0f6342eb01f54bca073ac1498433d6ce71e50c3c3282b655733b31/fonttools-4.61.1-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:10d88e55330e092940584774ee5e8a6971b01fc2f4d3466a1d6c158230880796", size = 4954103, upload-time = "2025-12-12T17:30:08.432Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/44/f3aeac0fa98e7ad527f479e161aca6c3a1e47bb6996b053d45226fe37bf2/fonttools-4.61.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:15acc09befd16a0fb8a8f62bc147e1a82817542d72184acca9ce6e0aeda9fa6d", size = 5004295, upload-time = "2025-12-12T17:30:10.56Z" },
+    { url = "https://files.pythonhosted.org/packages/14/e8/7424ced75473983b964d09f6747fa09f054a6d656f60e9ac9324cf40c743/fonttools-4.61.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e6bcdf33aec38d16508ce61fd81838f24c83c90a1d1b8c68982857038673d6b8", size = 4944109, upload-time = "2025-12-12T17:30:12.874Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/8b/6391b257fa3d0b553d73e778f953a2f0154292a7a7a085e2374b111e5410/fonttools-4.61.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5fade934607a523614726119164ff621e8c30e8fa1ffffbbd358662056ba69f0", size = 5093598, upload-time = "2025-12-12T17:30:15.79Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/71/fd2ea96cdc512d92da5678a1c98c267ddd4d8c5130b76d0f7a80f9a9fde8/fonttools-4.61.1-cp312-cp312-win32.whl", hash = "sha256:75da8f28eff26defba42c52986de97b22106cb8f26515b7c22443ebc9c2d3261", size = 2269060, upload-time = "2025-12-12T17:30:18.058Z" },
+    { url = "https://files.pythonhosted.org/packages/80/3b/a3e81b71aed5a688e89dfe0e2694b26b78c7d7f39a5ffd8a7d75f54a12a8/fonttools-4.61.1-cp312-cp312-win_amd64.whl", hash = "sha256:497c31ce314219888c0e2fce5ad9178ca83fe5230b01a5006726cdf3ac9f24d9", size = 2319078, upload-time = "2025-12-12T17:30:22.862Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/cf/00ba28b0990982530addb8dc3e9e6f2fa9cb5c20df2abdda7baa755e8fe1/fonttools-4.61.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8c56c488ab471628ff3bfa80964372fc13504ece601e0d97a78ee74126b2045c", size = 2846454, upload-time = "2025-12-12T17:30:24.938Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/ca/468c9a8446a2103ae645d14fee3f610567b7042aba85031c1c65e3ef7471/fonttools-4.61.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dc492779501fa723b04d0ab1f5be046797fee17d27700476edc7ee9ae535a61e", size = 2398191, upload-time = "2025-12-12T17:30:27.343Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/4b/d67eedaed19def5967fade3297fed8161b25ba94699efc124b14fb68cdbc/fonttools-4.61.1-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:64102ca87e84261419c3747a0d20f396eb024bdbeb04c2bfb37e2891f5fadcb5", size = 4928410, upload-time = "2025-12-12T17:30:29.771Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/8d/6fb3494dfe61a46258cd93d979cf4725ded4eb46c2a4ca35e4490d84daea/fonttools-4.61.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c1b526c8d3f615a7b1867f38a9410849c8f4aef078535742198e942fba0e9bd", size = 4984460, upload-time = "2025-12-12T17:30:32.073Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/f1/a47f1d30b3dc00d75e7af762652d4cbc3dff5c2697a0dbd5203c81afd9c3/fonttools-4.61.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:41ed4b5ec103bd306bb68f81dc166e77409e5209443e5773cb4ed837bcc9b0d3", size = 4925800, upload-time = "2025-12-12T17:30:34.339Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/01/e6ae64a0981076e8a66906fab01539799546181e32a37a0257b77e4aa88b/fonttools-4.61.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b501c862d4901792adaec7c25b1ecc749e2662543f68bb194c42ba18d6eec98d", size = 5067859, upload-time = "2025-12-12T17:30:36.593Z" },
+    { url = "https://files.pythonhosted.org/packages/73/aa/28e40b8d6809a9b5075350a86779163f074d2b617c15d22343fce81918db/fonttools-4.61.1-cp313-cp313-win32.whl", hash = "sha256:4d7092bb38c53bbc78e9255a59158b150bcdc115a1e3b3ce0b5f267dc35dd63c", size = 2267821, upload-time = "2025-12-12T17:30:38.478Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/59/453c06d1d83dc0951b69ef692d6b9f1846680342927df54e9a1ca91c6f90/fonttools-4.61.1-cp313-cp313-win_amd64.whl", hash = "sha256:21e7c8d76f62ab13c9472ccf74515ca5b9a761d1bde3265152a6dc58700d895b", size = 2318169, upload-time = "2025-12-12T17:30:40.951Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/4e/ce75a57ff3aebf6fc1f4e9d508b8e5810618a33d900ad6c19eb30b290b97/fonttools-4.61.1-py3-none-any.whl", hash = "sha256:17d2bf5d541add43822bcf0c43d7d847b160c9bb01d15d5007d84e2217aaa371", size = 1148996, upload-time = "2025-12-12T17:31:21.03Z" },
+]
+
+[[package]]
+name = "fsspec"
+version = "2025.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/de/e0/bab50af11c2d75c9c4a2a26a5254573c0bd97cea152254401510950486fa/fsspec-2025.9.0.tar.gz", hash = "sha256:19fd429483d25d28b65ec68f9f4adc16c17ea2c7c7bf54ec61360d478fb19c19", size = 304847, upload-time = "2025-09-02T19:10:49.215Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/47/71/70db47e4f6ce3e5c37a607355f80da8860a33226be640226ac52cb05ef2e/fsspec-2025.9.0-py3-none-any.whl", hash = "sha256:530dc2a2af60a414a832059574df4a6e10cce927f6f4a78209390fe38955cfb7", size = 199289, upload-time = "2025-09-02T19:10:47.708Z" },
+]
+
+[[package]]
+name = "gitdb"
+version = "4.0.12"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "smmap" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/63b0fc47eb32792c7ba1fe1b694daec9a63620db1e313033d18140c2320a/gitdb-4.0.12.tar.gz", hash = "sha256:5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571", size = 394684, upload-time = "2025-01-02T07:20:46.413Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/61/5c78b91c3143ed5c14207f463aecfc8f9dbb5092fb2869baf37c273b2705/gitdb-4.0.12-py3-none-any.whl", hash = "sha256:67073e15955400952c6565cc3e707c554a4eea2e428946f7a4c162fab9bd9bcf", size = 62794, upload-time = "2025-01-02T07:20:43.624Z" },
+]
+
+[[package]]
+name = "gitpython"
+version = "3.1.58"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "gitdb" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/26/d6/5f358ff283325580c2003a6d953aea18cfe10ae87b46f5ebc80fa3a386dc/gitpython-3.1.58.tar.gz", hash = "sha256:621416df10ef3fd0e19fabf9172ddeed0fa704d353d04f194eec56a625a95b22", size = 228498, upload-time = "2026-08-04T15:05:49.47Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/0c/9d8752098bc442f0726e64aa6135940b3a96809915d1aa4206c1bb97881d/gitpython-3.1.58-py3-none-any.whl", hash = "sha256:d331e722577f0fd7fc1f857419b3ecc07af66282b933d2a4d95f84a042fdd50f", size = 220183, upload-time = "2026-08-04T15:05:48.025Z" },
+]
+
+[[package]]
+name = "glfw"
+version = "2.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/72/642d4f12f61816ac96777f7360d413e3977a7dd08237d196f02da681b186/glfw-2.10.0.tar.gz", hash = "sha256:801e55d8581b34df9aa2cfea43feb06ff617576e2a8cc5dac23ee75b26d10abe", size = 31475, upload-time = "2025-09-12T08:54:38.871Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/1f/a9ce08b1173b0ab625ee92f0c47a5278b3e76fd367699880d8ee7d56c338/glfw-2.10.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.p39.p310.p311.p312.p313-none-macosx_10_6_intel.whl", hash = "sha256:5f365a8c94bcea71ec91327e7c16e7cf739128479a18b8c1241b004b40acc412", size = 105329, upload-time = "2025-09-12T08:54:27.938Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/96/5a2220abcbd027eebcf8bedd28207a2de168899e51be13ba01ebdd4147a1/glfw-2.10.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.p39.p310.p311.p312.p313-none-macosx_11_0_arm64.whl", hash = "sha256:5328db1a92d07abd988730517ec02aa8390d3e6ef7ce98c8b57ecba2f43a39ba", size = 102179, upload-time = "2025-09-12T08:54:29.163Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/41/a5bd1d9e1808f400102bd7d328c4ac17b65fb2fc8014014ec6f23d02f662/glfw-2.10.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.p39.p310.p311.p312.p313-none-manylinux2014_aarch64.whl", hash = "sha256:312c4c1dd5509613ed6bc1e95a8dbb75a36b6dcc4120f50dc3892b40172e9053", size = 230039, upload-time = "2025-09-12T08:54:30.201Z" },
+    { url = "https://files.pythonhosted.org/packages/80/aa/3b503c448609dee6cb4e7138b4109338f0e65b97be107ab85562269d378d/glfw-2.10.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.p39.p310.p311.p312.p313-none-manylinux2014_x86_64.whl", hash = "sha256:59c53387dc08c62e8bed86bbe3a8d53ab1b27161281ffa0e7f27b64284e2627c", size = 241984, upload-time = "2025-09-12T08:54:31.347Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/2d/bfe39a42cad8e80b02bf5f7cae19ba67832c1810bbd3624a8e83153d74a4/glfw-2.10.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.p39.p310.p311.p312.p313-none-manylinux_2_28_aarch64.whl", hash = "sha256:c6f292fdaf3f9a99e598ede6582d21c523a6f51f8f5e66213849101a6bcdc699", size = 231052, upload-time = "2025-09-12T08:54:32.859Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/02/6e639e90f181dc9127046e00d0528f9f7ad12d428972e3a5378b9aefdb0b/glfw-2.10.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.p39.p310.p311.p312.p313-none-manylinux_2_28_x86_64.whl", hash = "sha256:7916034efa867927892635733a3b6af8cd95ceb10566fd7f1e0d2763c2ee8b12", size = 243525, upload-time = "2025-09-12T08:54:34.006Z" },
+    { url = "https://files.pythonhosted.org/packages/84/06/cb588ca65561defe0fc48d1df4c2ac12569b81231ae4f2b52ab37007d0bd/glfw-2.10.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.p39.p310.p311.p312.p313-none-win32.whl", hash = "sha256:6c9549da71b93e367b4d71438798daae1da2592039fd14204a80a1a2348ae127", size = 552685, upload-time = "2025-09-12T08:54:35.723Z" },
+    { url = "https://files.pythonhosted.org/packages/86/27/00c9c96af18ac0a5eac2ff61cbe306551a2d770d7173f396d0792ee1a59e/glfw-2.10.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.p39.p310.p311.p312.p313-none-win_amd64.whl", hash = "sha256:6292d5d6634d668cd23d337e6089491d3945a9aa4ac6e1667b0003520d7caa51", size = 559466, upload-time = "2025-09-12T08:54:37.661Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/87/de0b33f6f00687499ca1371f22aa73396341b85bf88f1a284f9da8842493/glfw-2.10.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.py39.py310.py311.py312.py313.py314-none-macosx_10_6_intel.whl", hash = "sha256:2aab89d2d9535635ba011fc7303390685169a1aa6731ad580d08d043524b8899", size = 105326, upload-time = "2026-01-28T05:57:56.083Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/a6/6ea2f73ad4474896d9e38b3ffbe6ffd5a802c738392269e99e8c6621a461/glfw-2.10.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.py39.py310.py311.py312.py313.py314-none-macosx_11_0_arm64.whl", hash = "sha256:23936202a107039b5372f0b88ae1d11080746aa1c78910a45d4a0c4cf408cfaa", size = 102180, upload-time = "2026-01-28T05:57:57.787Z" },
+    { url = "https://files.pythonhosted.org/packages/58/19/d81b19e8261b9cb51b81d1402167791fef81088dfe91f0c4e9d136fdc5ca/glfw-2.10.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.py39.py310.py311.py312.py313.py314-none-manylinux2014_aarch64.whl", hash = "sha256:7be06d0838f61df67bd54cb6266a6193d54083acb3624ff3c3812a6358406fa4", size = 230038, upload-time = "2026-01-28T05:57:59.105Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/fa/b035636cd82198b97b51a93efe9cfc4343d6b15cefbd336a3f2be871d848/glfw-2.10.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.py39.py310.py311.py312.py313.py314-none-manylinux2014_x86_64.whl", hash = "sha256:91d36b3582a766512eff8e3b5dcc2d3ffcbf10b7cf448551085a08a10f1b8244", size = 241983, upload-time = "2026-01-28T05:58:00.352Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b4/f7b6cc022dd7c68b6c702d19da5d591f978f89c958b9bd3090615db0c739/glfw-2.10.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.py39.py310.py311.py312.py313.py314-none-manylinux_2_28_aarch64.whl", hash = "sha256:27c9e9a2d5e1dc3c9e3996171d844d9df9a5a101e797cb94cce217b7afcf8fd9", size = 231053, upload-time = "2026-01-28T05:58:01.683Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/3f/efeb7c6801c46e11bd666a5180f0d615f74f72264212f74f39586c6fda9d/glfw-2.10.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.py39.py310.py311.py312.py313.py314-none-manylinux_2_28_x86_64.whl", hash = "sha256:ce6724bb7cb3d0543dcba17206dce909f94176e68220b8eafee72e9f92bcf542", size = 243522, upload-time = "2026-01-28T05:58:03.517Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/b9/b04c3aa0aad2870cfe799f32f8b59789c98e1816bbce9e83f4823c5b840b/glfw-2.10.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.py39.py310.py311.py312.py313.py314-none-win32.whl", hash = "sha256:fca724a21a372731edb290841edd28a9fb1ee490f833392752844ac807c0086a", size = 552682, upload-time = "2026-01-28T05:58:05.649Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/e1/6d6816b296a529ac9b897ad228b1e084eb1f92319e96371880eebdc874a6/glfw-2.10.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.py39.py310.py311.py312.py313.py314-none-win_amd64.whl", hash = "sha256:823c0bd7770977d4b10e0ed0aef2f3682276b7c88b8b65cfc540afce5951392f", size = 559464, upload-time = "2026-01-28T05:58:07.261Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/a8/d4dab8a58fc2e6981fc7a58c4e56ba9d777fb24931cec6a22152edbb3540/glfw-2.10.0-py2.py3-none-macosx_10_6_intel.whl", hash = "sha256:a0d1f29f206219cc291edfb6cace663a86da2470632551c998e3db82d48ea177", size = 105288, upload-time = "2026-03-10T17:21:19.929Z" },
+    { url = "https://files.pythonhosted.org/packages/14/61/68d35e001872a7705112418da236fa2418d4f2e5419f8b2837f9b81bb3da/glfw-2.10.0-py2.py3-none-macosx_11_0_arm64.whl", hash = "sha256:d28d6f3ef217e64e35dc6fd0a7acb4cec9bfe7cd14dd9b35a7228a87002de154", size = 102139, upload-time = "2026-03-10T17:21:21.645Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/e1/ca5984081aaae07c9d371cb11dc4e4ff603510678ed9b73e58b6c351fe63/glfw-2.10.0-py2.py3-none-manylinux2014_aarch64.whl", hash = "sha256:f968b522bb6a0e04aaf4dcac30a476d7229308bb2bac406a60587debb5a61e29", size = 229998, upload-time = "2026-03-10T17:21:23.549Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/c4/82ac75fdcfba2896da7a573c0fc7f8ceb8f77ead6866d500d06c32f1c464/glfw-2.10.0-py2.py3-none-manylinux2014_x86_64.whl", hash = "sha256:68cf3752bdadb6f4bc0a876247c28c88c7251ac39f8af076ed938fdfd71e72dd", size = 241944, upload-time = "2026-03-10T17:21:26.102Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/96/9f691823cca5eb6a08f346bd0ff03b78032db9370b509a1e9c8976fb20a5/glfw-2.10.0-py2.py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:44d98de5dbf8f727e0cb29f9b29d29528ea7570f2e6f42f8430a69df05f12b48", size = 231009, upload-time = "2026-03-10T17:21:28.481Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/93/977b9e679e356871d428ae7a1139ec767dd5177bed58a6344b4d2199e00f/glfw-2.10.0-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:cca5158d62189e08792b1ae54f92307a282921a0e7783315b467e21b0a381c88", size = 243480, upload-time = "2026-03-10T17:21:30.538Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/bd/cea9569c8f2188b0a104472951420434a3e1f5cf26f5836ef9d7227a1a30/glfw-2.10.0-py2.py3-none-win32.whl", hash = "sha256:5e024509989740e8e7b86cc4aab508195495f79879072b0e1f68bd036a2916ad", size = 552641, upload-time = "2026-03-10T17:21:32.653Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/9b/4366ad3e1c0688146c70aa6143584d6a8d88583b9390f106250e25a3d5cd/glfw-2.10.0-py2.py3-none-win_amd64.whl", hash = "sha256:7f787ee8645781f10e8800438ce4357ab38c573ffb191aba380c1e72eba6311c", size = 559423, upload-time = "2026-03-10T17:21:34.766Z" },
+]
+
+[[package]]
+name = "grpcio"
+version = "1.76.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b6/e0/318c1ce3ae5a17894d5791e87aea147587c9e702f24122cc7a5c8bbaeeb1/grpcio-1.76.0.tar.gz", hash = "sha256:7be78388d6da1a25c0d5ec506523db58b18be22d9c37d8d3a32c08be4987bd73", size = 12785182, upload-time = "2025-10-21T16:23:12.106Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/17/ff4795dc9a34b6aee6ec379f1b66438a3789cd1315aac0cbab60d92f74b3/grpcio-1.76.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:65a20de41e85648e00305c1bb09a3598f840422e522277641145a32d42dcefcc", size = 5840037, upload-time = "2025-10-21T16:20:25.069Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/ff/35f9b96e3fa2f12e1dcd58a4513a2e2294a001d64dec81677361b7040c9a/grpcio-1.76.0-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:40ad3afe81676fd9ec6d9d406eda00933f218038433980aa19d401490e46ecde", size = 11836482, upload-time = "2025-10-21T16:20:30.113Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/1c/8374990f9545e99462caacea5413ed783014b3b66ace49e35c533f07507b/grpcio-1.76.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:035d90bc79eaa4bed83f524331d55e35820725c9fbb00ffa1904d5550ed7ede3", size = 6407178, upload-time = "2025-10-21T16:20:32.733Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/77/36fd7d7c75a6c12542c90a6d647a27935a1ecaad03e0ffdb7c42db6b04d2/grpcio-1.76.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:4215d3a102bd95e2e11b5395c78562967959824156af11fa93d18fdd18050990", size = 7075684, upload-time = "2025-10-21T16:20:35.435Z" },
+    { url = "https://files.pythonhosted.org/packages/38/f7/e3cdb252492278e004722306c5a8935eae91e64ea11f0af3437a7de2e2b7/grpcio-1.76.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:49ce47231818806067aea3324d4bf13825b658ad662d3b25fada0bdad9b8a6af", size = 6611133, upload-time = "2025-10-21T16:20:37.541Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/20/340db7af162ccd20a0893b5f3c4a5d676af7b71105517e62279b5b61d95a/grpcio-1.76.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:8cc3309d8e08fd79089e13ed4819d0af72aa935dd8f435a195fd152796752ff2", size = 7195507, upload-time = "2025-10-21T16:20:39.643Z" },
+    { url = "https://files.pythonhosted.org/packages/10/f0/b2160addc1487bd8fa4810857a27132fb4ce35c1b330c2f3ac45d697b106/grpcio-1.76.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:971fd5a1d6e62e00d945423a567e42eb1fa678ba89072832185ca836a94daaa6", size = 8160651, upload-time = "2025-10-21T16:20:42.492Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/2c/ac6f98aa113c6ef111b3f347854e99ebb7fb9d8f7bb3af1491d438f62af4/grpcio-1.76.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9d9adda641db7207e800a7f089068f6f645959f2df27e870ee81d44701dd9db3", size = 7620568, upload-time = "2025-10-21T16:20:45.995Z" },
+    { url = "https://files.pythonhosted.org/packages/90/84/7852f7e087285e3ac17a2703bc4129fafee52d77c6c82af97d905566857e/grpcio-1.76.0-cp310-cp310-win32.whl", hash = "sha256:063065249d9e7e0782d03d2bca50787f53bd0fb89a67de9a7b521c4a01f1989b", size = 3998879, upload-time = "2025-10-21T16:20:48.592Z" },
+    { url = "https://files.pythonhosted.org/packages/10/30/d3d2adcbb6dd3ff59d6ac3df6ef830e02b437fb5c90990429fd180e52f30/grpcio-1.76.0-cp310-cp310-win_amd64.whl", hash = "sha256:a6ae758eb08088d36812dd5d9af7a9859c05b1e0f714470ea243694b49278e7b", size = 4706892, upload-time = "2025-10-21T16:20:50.697Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/00/8163a1beeb6971f66b4bbe6ac9457b97948beba8dd2fc8e1281dce7f79ec/grpcio-1.76.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:2e1743fbd7f5fa713a1b0a8ac8ebabf0ec980b5d8809ec358d488e273b9cf02a", size = 5843567, upload-time = "2025-10-21T16:20:52.829Z" },
+    { url = "https://files.pythonhosted.org/packages/10/c1/934202f5cf335e6d852530ce14ddb0fef21be612ba9ecbbcbd4d748ca32d/grpcio-1.76.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:a8c2cf1209497cf659a667d7dea88985e834c24b7c3b605e6254cbb5076d985c", size = 11848017, upload-time = "2025-10-21T16:20:56.705Z" },
+    { url = "https://files.pythonhosted.org/packages/11/0b/8dec16b1863d74af6eb3543928600ec2195af49ca58b16334972f6775663/grpcio-1.76.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:08caea849a9d3c71a542827d6df9d5a69067b0a1efbea8a855633ff5d9571465", size = 6412027, upload-time = "2025-10-21T16:20:59.3Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/64/7b9e6e7ab910bea9d46f2c090380bab274a0b91fb0a2fe9b0cd399fffa12/grpcio-1.76.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:f0e34c2079d47ae9f6188211db9e777c619a21d4faba6977774e8fa43b085e48", size = 7075913, upload-time = "2025-10-21T16:21:01.645Z" },
+    { url = "https://files.pythonhosted.org/packages/68/86/093c46e9546073cefa789bd76d44c5cb2abc824ca62af0c18be590ff13ba/grpcio-1.76.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8843114c0cfce61b40ad48df65abcfc00d4dba82eae8718fab5352390848c5da", size = 6615417, upload-time = "2025-10-21T16:21:03.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/b6/5709a3a68500a9c03da6fb71740dcdd5ef245e39266461a03f31a57036d8/grpcio-1.76.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8eddfb4d203a237da6f3cc8a540dad0517d274b5a1e9e636fd8d2c79b5c1d397", size = 7199683, upload-time = "2025-10-21T16:21:06.195Z" },
+    { url = "https://files.pythonhosted.org/packages/91/d3/4b1f2bf16ed52ce0b508161df3a2d186e4935379a159a834cb4a7d687429/grpcio-1.76.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:32483fe2aab2c3794101c2a159070584e5db11d0aa091b2c0ea9c4fc43d0d749", size = 8163109, upload-time = "2025-10-21T16:21:08.498Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/61/d9043f95f5f4cf085ac5dd6137b469d41befb04bd80280952ffa2a4c3f12/grpcio-1.76.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:dcfe41187da8992c5f40aa8c5ec086fa3672834d2be57a32384c08d5a05b4c00", size = 7626676, upload-time = "2025-10-21T16:21:10.693Z" },
+    { url = "https://files.pythonhosted.org/packages/36/95/fd9a5152ca02d8881e4dd419cdd790e11805979f499a2e5b96488b85cf27/grpcio-1.76.0-cp311-cp311-win32.whl", hash = "sha256:2107b0c024d1b35f4083f11245c0e23846ae64d02f40b2b226684840260ed054", size = 3997688, upload-time = "2025-10-21T16:21:12.746Z" },
+    { url = "https://files.pythonhosted.org/packages/60/9c/5c359c8d4c9176cfa3c61ecd4efe5affe1f38d9bae81e81ac7186b4c9cc8/grpcio-1.76.0-cp311-cp311-win_amd64.whl", hash = "sha256:522175aba7af9113c48ec10cc471b9b9bd4f6ceb36aeb4544a8e2c80ed9d252d", size = 4709315, upload-time = "2025-10-21T16:21:15.26Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/05/8e29121994b8d959ffa0afd28996d452f291b48cfc0875619de0bde2c50c/grpcio-1.76.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:81fd9652b37b36f16138611c7e884eb82e0cec137c40d3ef7c3f9b3ed00f6ed8", size = 5799718, upload-time = "2025-10-21T16:21:17.939Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/75/11d0e66b3cdf998c996489581bdad8900db79ebd83513e45c19548f1cba4/grpcio-1.76.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:04bbe1bfe3a68bbfd4e52402ab7d4eb59d72d02647ae2042204326cf4bbad280", size = 11825627, upload-time = "2025-10-21T16:21:20.466Z" },
+    { url = "https://files.pythonhosted.org/packages/28/50/2f0aa0498bc188048f5d9504dcc5c2c24f2eb1a9337cd0fa09a61a2e75f0/grpcio-1.76.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d388087771c837cdb6515539f43b9d4bf0b0f23593a24054ac16f7a960be16f4", size = 6359167, upload-time = "2025-10-21T16:21:23.122Z" },
+    { url = "https://files.pythonhosted.org/packages/66/e5/bbf0bb97d29ede1d59d6588af40018cfc345b17ce979b7b45424628dc8bb/grpcio-1.76.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:9f8f757bebaaea112c00dba718fc0d3260052ce714e25804a03f93f5d1c6cc11", size = 7044267, upload-time = "2025-10-21T16:21:25.995Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/86/f6ec2164f743d9609691115ae8ece098c76b894ebe4f7c94a655c6b03e98/grpcio-1.76.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:980a846182ce88c4f2f7e2c22c56aefd515daeb36149d1c897f83cf57999e0b6", size = 6573963, upload-time = "2025-10-21T16:21:28.631Z" },
+    { url = "https://files.pythonhosted.org/packages/60/bc/8d9d0d8505feccfdf38a766d262c71e73639c165b311c9457208b56d92ae/grpcio-1.76.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f92f88e6c033db65a5ae3d97905c8fea9c725b63e28d5a75cb73b49bda5024d8", size = 7164484, upload-time = "2025-10-21T16:21:30.837Z" },
+    { url = "https://files.pythonhosted.org/packages/67/e6/5d6c2fc10b95edf6df9b8f19cf10a34263b7fd48493936fffd5085521292/grpcio-1.76.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4baf3cbe2f0be3289eb68ac8ae771156971848bb8aaff60bad42005539431980", size = 8127777, upload-time = "2025-10-21T16:21:33.577Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/c8/dce8ff21c86abe025efe304d9e31fdb0deaaa3b502b6a78141080f206da0/grpcio-1.76.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:615ba64c208aaceb5ec83bfdce7728b80bfeb8be97562944836a7a0a9647d882", size = 7594014, upload-time = "2025-10-21T16:21:41.882Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/42/ad28191ebf983a5d0ecef90bab66baa5a6b18f2bfdef9d0a63b1973d9f75/grpcio-1.76.0-cp312-cp312-win32.whl", hash = "sha256:45d59a649a82df5718fd9527ce775fd66d1af35e6d31abdcdc906a49c6822958", size = 3984750, upload-time = "2025-10-21T16:21:44.006Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/00/7bd478cbb851c04a48baccaa49b75abaa8e4122f7d86da797500cccdd771/grpcio-1.76.0-cp312-cp312-win_amd64.whl", hash = "sha256:c088e7a90b6017307f423efbb9d1ba97a22aa2170876223f9709e9d1de0b5347", size = 4704003, upload-time = "2025-10-21T16:21:46.244Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/ed/71467ab770effc9e8cef5f2e7388beb2be26ed642d567697bb103a790c72/grpcio-1.76.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:26ef06c73eb53267c2b319f43e6634c7556ea37672029241a056629af27c10e2", size = 5807716, upload-time = "2025-10-21T16:21:48.475Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/85/c6ed56f9817fab03fa8a111ca91469941fb514e3e3ce6d793cb8f1e1347b/grpcio-1.76.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:45e0111e73f43f735d70786557dc38141185072d7ff8dc1829d6a77ac1471468", size = 11821522, upload-time = "2025-10-21T16:21:51.142Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/31/2b8a235ab40c39cbc141ef647f8a6eb7b0028f023015a4842933bc0d6831/grpcio-1.76.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:83d57312a58dcfe2a3a0f9d1389b299438909a02db60e2f2ea2ae2d8034909d3", size = 6362558, upload-time = "2025-10-21T16:21:54.213Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/64/9784eab483358e08847498ee56faf8ff6ea8e0a4592568d9f68edc97e9e9/grpcio-1.76.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:3e2a27c89eb9ac3d81ec8835e12414d73536c6e620355d65102503064a4ed6eb", size = 7049990, upload-time = "2025-10-21T16:21:56.476Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/94/8c12319a6369434e7a184b987e8e9f3b49a114c489b8315f029e24de4837/grpcio-1.76.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:61f69297cba3950a524f61c7c8ee12e55c486cb5f7db47ff9dcee33da6f0d3ae", size = 6575387, upload-time = "2025-10-21T16:21:59.051Z" },
+    { url = "https://files.pythonhosted.org/packages/15/0f/f12c32b03f731f4a6242f771f63039df182c8b8e2cf8075b245b409259d4/grpcio-1.76.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6a15c17af8839b6801d554263c546c69c4d7718ad4321e3166175b37eaacca77", size = 7166668, upload-time = "2025-10-21T16:22:02.049Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/2d/3ec9ce0c2b1d92dd59d1c3264aaec9f0f7c817d6e8ac683b97198a36ed5a/grpcio-1.76.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:25a18e9810fbc7e7f03ec2516addc116a957f8cbb8cbc95ccc80faa072743d03", size = 8124928, upload-time = "2025-10-21T16:22:04.984Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/74/fd3317be5672f4856bcdd1a9e7b5e17554692d3db9a3b273879dc02d657d/grpcio-1.76.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:931091142fd8cc14edccc0845a79248bc155425eee9a98b2db2ea4f00a235a42", size = 7589983, upload-time = "2025-10-21T16:22:07.881Z" },
+    { url = "https://files.pythonhosted.org/packages/45/bb/ca038cf420f405971f19821c8c15bcbc875505f6ffadafe9ffd77871dc4c/grpcio-1.76.0-cp313-cp313-win32.whl", hash = "sha256:5e8571632780e08526f118f74170ad8d50fb0a48c23a746bef2a6ebade3abd6f", size = 3984727, upload-time = "2025-10-21T16:22:10.032Z" },
+    { url = "https://files.pythonhosted.org/packages/41/80/84087dc56437ced7cdd4b13d7875e7439a52a261e3ab4e06488ba6173b0a/grpcio-1.76.0-cp313-cp313-win_amd64.whl", hash = "sha256:f9f7bd5faab55f47231ad8dba7787866b69f5e93bc306e3915606779bbfb4ba8", size = 4702799, upload-time = "2025-10-21T16:22:12.709Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "identify"
+version = "2.6.15"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ff/e7/685de97986c916a6d93b3876139e00eef26ad5bbbd61925d670ae8013449/identify-2.6.15.tar.gz", hash = "sha256:e4f4864b96c6557ef2a1e1c951771838f4edc9df3a72ec7118b338801b11c7bf", size = 99311, upload-time = "2025-10-02T17:43:40.631Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/1c/e5fd8f973d4f375adb21565739498e2e9a1e54c858a97b9a8ccfdc81da9b/identify-2.6.15-py2.py3-none-any.whl", hash = "sha256:1181ef7608e00704db228516541eb83a88a9f94433a8c80bb9b5bd54b1d81757", size = 99183, upload-time = "2025-10-02T17:43:39.137Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.18"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/63/9496c57188a2ee585e0f1db071d75089a11e98aa86eb99d9d7618fc1edce/idna-3.18.tar.gz", hash = "sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848", size = 196711, upload-time = "2026-06-02T14:34:07.794Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl", hash = "sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2", size = 65455, upload-time = "2026-06-02T14:34:06.319Z" },
+]
+
+[[package]]
+name = "imageio"
+version = "2.37.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "pillow" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0c/47/57e897fb7094afb2d26e8b2e4af9a45c7cf1a405acdeeca001fdf2c98501/imageio-2.37.0.tar.gz", hash = "sha256:71b57b3669666272c818497aebba2b4c5f20d5b37c81720e5e1a56d59c492996", size = 389963, upload-time = "2025-01-20T02:42:37.089Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/bd/b394387b598ed84d8d0fa90611a90bee0adc2021820ad5729f7ced74a8e2/imageio-2.37.0-py3-none-any.whl", hash = "sha256:11efa15b87bc7871b61590326b2d635439acc321cf7f8ce996f812543ce10eed", size = 315796, upload-time = "2025-01-20T02:42:34.931Z" },
+]
+
+[[package]]
+name = "imageio-ffmpeg"
+version = "0.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/44/bd/c3343c721f2a1b0c9fc71c1aebf1966a3b7f08c2eea8ed5437a2865611d6/imageio_ffmpeg-0.6.0.tar.gz", hash = "sha256:e2556bed8e005564a9f925bb7afa4002d82770d6b08825078b7697ab88ba1755", size = 25210, upload-time = "2025-01-16T21:34:32.747Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/58/87ef68ac83f4c7690961bce288fd8e382bc5f1513860fc7f90a9c1c1c6bf/imageio_ffmpeg-0.6.0-py3-none-macosx_10_9_intel.macosx_10_9_x86_64.whl", hash = "sha256:9d2baaf867088508d4a3458e61eeb30e945c4ad8016025545f66c4b5aaef0a61", size = 24932969, upload-time = "2025-01-16T21:34:20.464Z" },
+    { url = "https://files.pythonhosted.org/packages/40/5c/f3d8a657d362cc93b81aab8feda487317da5b5d31c0e1fdfd5e986e55d17/imageio_ffmpeg-0.6.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:b1ae3173414b5fc5f538a726c4e48ea97edc0d2cdc11f103afee655c463fa742", size = 21113891, upload-time = "2025-01-16T21:34:00.277Z" },
+    { url = "https://files.pythonhosted.org/packages/33/e7/1925bfbc563c39c1d2e82501d8372734a5c725e53ac3b31b4c2d081e895b/imageio_ffmpeg-0.6.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:1d47bebd83d2c5fc770720d211855f208af8a596c82d17730aa51e815cdee6dc", size = 25632706, upload-time = "2025-01-16T21:33:53.475Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/2d/43c8522a2038e9d0e7dbdf3a61195ecc31ca576fb1527a528c877e87d973/imageio_ffmpeg-0.6.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:c7e46fcec401dd990405049d2e2f475e2b397779df2519b544b8aab515195282", size = 29498237, upload-time = "2025-01-16T21:34:13.726Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/13/59da54728351883c3c1d9fca1710ab8eee82c7beba585df8f25ca925f08f/imageio_ffmpeg-0.6.0-py3-none-win32.whl", hash = "sha256:196faa79366b4a82f95c0f4053191d2013f4714a715780f0ad2a68ff37483cc2", size = 19652251, upload-time = "2025-01-16T21:34:06.812Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/c6/fa760e12a2483469e2bf5058c5faff664acf66cadb4df2ad6205b016a73d/imageio_ffmpeg-0.6.0-py3-none-win_amd64.whl", hash = "sha256:02fa47c83703c37df6bfe4896aab339013f62bf02c5ebf2dce6da56af04ffc0a", size = 31246824, upload-time = "2025-01-16T21:34:28.6Z" },
+]
+
+[[package]]
+name = "imagesize"
+version = "1.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a7/84/62473fb57d61e31fef6e36d64a179c8781605429fd927b5dd608c997be31/imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a", size = 1280026, upload-time = "2022-07-01T12:21:05.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", size = 8769, upload-time = "2022-07-01T12:21:02.467Z" },
+]
+
+[[package]]
+name = "importlib-metadata"
+version = "8.7.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "zipp" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641, upload-time = "2025-04-27T15:29:01.736Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/b0/36bd937216ec521246249be3bf9855081de4c5e06a0c9b4219dbeda50373/importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd", size = 27656, upload-time = "2025-04-27T15:29:00.214Z" },
+]
+
+[[package]]
+name = "importlib-resources"
+version = "6.5.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cf/8c/f834fbf984f691b4f7ff60f50b514cc3de5cc08abfc3295564dd89c5e2e7/importlib_resources-6.5.2.tar.gz", hash = "sha256:185f87adef5bcc288449d98fb4fba07cea78bc036455dd44c5fc4a2fe78fed2c", size = 44693, upload-time = "2025-01-03T18:51:56.698Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/ed/1f1afb2e9e7f38a545d628f864d562a5ae64fe6f7a10e28ffb9b185b4e89/importlib_resources-6.5.2-py3-none-any.whl", hash = "sha256:789cfdc3ed28c78b67a06acb8126751ced69a3d5f79c095a98298cd8a760ccec", size = 37461, upload-time = "2025-01-03T18:51:54.306Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "invoke"
+version = "2.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/de/bd/b461d3424a24c80490313fd77feeb666ca4f6a28c7e72713e3d9095719b4/invoke-2.2.1.tar.gz", hash = "sha256:515bf49b4a48932b79b024590348da22f39c4942dff991ad1fb8b8baea1be707", size = 304762, upload-time = "2025-10-11T00:36:35.172Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/4b/b99e37f88336009971405cbb7630610322ed6fbfa31e1d7ab3fbf3049a2d/invoke-2.2.1-py3-none-any.whl", hash = "sha256:2413bc441b376e5cd3f55bb5d364f973ad8bdd7bf87e53c79de3c11bf3feecc8", size = 160287, upload-time = "2025-10-11T00:36:33.703Z" },
+]
+
+[[package]]
+name = "ipdb"
+version = "0.13.13"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "decorator" },
+    { name = "ipython", version = "8.37.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "ipython", version = "9.6.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "tomli", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/1b/7e07e7b752017f7693a0f4d41c13e5ca29ce8cbcfdcc1fd6c4ad8c0a27a0/ipdb-0.13.13.tar.gz", hash = "sha256:e3ac6018ef05126d442af680aad863006ec19d02290561ac88b8b1c0b0cfc726", size = 17042, upload-time = "2023-03-09T15:40:57.487Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/4c/b075da0092003d9a55cf2ecc1cae9384a1ca4f650d51b00fc59875fe76f6/ipdb-0.13.13-py3-none-any.whl", hash = "sha256:45529994741c4ab6d2388bfa5d7b725c2cf7fe9deffabdb8a6113aa5ed449ed4", size = 12130, upload-time = "2023-03-09T15:40:55.021Z" },
+]
+
+[[package]]
+name = "ipython"
+version = "8.37.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+dependencies = [
+    { name = "colorama", marker = "(python_full_version < '3.11' and sys_platform == 'win32') or (python_full_version >= '3.11' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform != 'win32' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "decorator", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "jedi", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "matplotlib-inline", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "pexpect", marker = "(python_full_version < '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32') or (python_full_version >= '3.11' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform == 'emscripten' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform == 'win32' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "prompt-toolkit", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "pygments", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "stack-data", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "traitlets", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/85/31/10ac88f3357fc276dc8a64e8880c82e80e7459326ae1d0a211b40abf6665/ipython-8.37.0.tar.gz", hash = "sha256:ca815841e1a41a1e6b73a0b08f3038af9b2252564d01fc405356d34033012216", size = 5606088, upload-time = "2025-05-31T16:39:09.613Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/91/d0/274fbf7b0b12643cbbc001ce13e6a5b1607ac4929d1b11c72460152c9fc3/ipython-8.37.0-py3-none-any.whl", hash = "sha256:ed87326596b878932dbcb171e3e698845434d8c61b8d8cd474bf663041a9dcf2", size = 831864, upload-time = "2025-05-31T16:39:06.38Z" },
+]
+
+[[package]]
+name = "ipython"
+version = "9.6.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+dependencies = [
+    { name = "colorama", marker = "(python_full_version >= '3.11' and sys_platform == 'win32') or (python_full_version < '3.11' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform != 'win32' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "decorator", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "ipython-pygments-lexers", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "jedi", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "matplotlib-inline", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "pexpect", marker = "(python_full_version >= '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32') or (python_full_version < '3.11' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform == 'emscripten' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform == 'win32' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "prompt-toolkit", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "pygments", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "stack-data", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "traitlets", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "typing-extensions", marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2a/34/29b18c62e39ee2f7a6a3bba7efd952729d8aadd45ca17efc34453b717665/ipython-9.6.0.tar.gz", hash = "sha256:5603d6d5d356378be5043e69441a072b50a5b33b4503428c77b04cb8ce7bc731", size = 4396932, upload-time = "2025-09-29T10:55:53.948Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/48/c5/d5e07995077e48220269c28a221e168c91123ad5ceee44d548f54a057fc0/ipython-9.6.0-py3-none-any.whl", hash = "sha256:5f77efafc886d2f023442479b8149e7d86547ad0a979e9da9f045d252f648196", size = 616170, upload-time = "2025-09-29T10:55:47.676Z" },
+]
+
+[[package]]
+name = "ipython-pygments-lexers"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pygments", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" },
+]
+
+[[package]]
+name = "jedi"
+version = "0.19.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "parso" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278, upload-time = "2024-11-11T01:41:40.175Z" },
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
+]
+
+[[package]]
+name = "jsonschema"
+version = "4.25.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "jsonschema-specifications" },
+    { name = "referencing" },
+    { name = "rpds-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/74/69/f7185de793a29082a9f3c7728268ffb31cb5095131a9c139a74078e27336/jsonschema-4.25.1.tar.gz", hash = "sha256:e4a9655ce0da0c0b67a085847e00a3a51449e1157f4f75e9fb5aa545e122eb85", size = 357342, upload-time = "2025-08-18T17:03:50.038Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bf/9c/8c95d856233c1f82500c2450b8c68576b4cf1c871db3afac5c34ff84e6fd/jsonschema-4.25.1-py3-none-any.whl", hash = "sha256:3fba0169e345c7175110351d456342c364814cfcf3b964ba4587f22915230a63", size = 90040, upload-time = "2025-08-18T17:03:48.373Z" },
+]
+
+[[package]]
+name = "jsonschema-specifications"
+version = "2025.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "referencing" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" },
+]
+
+[[package]]
+name = "kiwisolver"
+version = "1.4.9"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5c/3c/85844f1b0feb11ee581ac23fe5fce65cd049a200c1446708cc1b7f922875/kiwisolver-1.4.9.tar.gz", hash = "sha256:c3b22c26c6fd6811b0ae8363b95ca8ce4ea3c202d3d0975b2914310ceb1bcc4d", size = 97564, upload-time = "2025-08-10T21:27:49.279Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c6/5d/8ce64e36d4e3aac5ca96996457dcf33e34e6051492399a3f1fec5657f30b/kiwisolver-1.4.9-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b4b4d74bda2b8ebf4da5bd42af11d02d04428b2c32846e4c2c93219df8a7987b", size = 124159, upload-time = "2025-08-10T21:25:35.472Z" },
+    { url = "https://files.pythonhosted.org/packages/96/1e/22f63ec454874378175a5f435d6ea1363dd33fb2af832c6643e4ccea0dc8/kiwisolver-1.4.9-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:fb3b8132019ea572f4611d770991000d7f58127560c4889729248eb5852a102f", size = 66578, upload-time = "2025-08-10T21:25:36.73Z" },
+    { url = "https://files.pythonhosted.org/packages/41/4c/1925dcfff47a02d465121967b95151c82d11027d5ec5242771e580e731bd/kiwisolver-1.4.9-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:84fd60810829c27ae375114cd379da1fa65e6918e1da405f356a775d49a62bcf", size = 65312, upload-time = "2025-08-10T21:25:37.658Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/42/0f333164e6307a0687d1eb9ad256215aae2f4bd5d28f4653d6cd319a3ba3/kiwisolver-1.4.9-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:b78efa4c6e804ecdf727e580dbb9cba85624d2e1c6b5cb059c66290063bd99a9", size = 1628458, upload-time = "2025-08-10T21:25:39.067Z" },
+    { url = "https://files.pythonhosted.org/packages/86/b6/2dccb977d651943995a90bfe3495c2ab2ba5cd77093d9f2318a20c9a6f59/kiwisolver-1.4.9-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4efec7bcf21671db6a3294ff301d2fc861c31faa3c8740d1a94689234d1b415", size = 1225640, upload-time = "2025-08-10T21:25:40.489Z" },
+    { url = "https://files.pythonhosted.org/packages/50/2b/362ebd3eec46c850ccf2bfe3e30f2fc4c008750011f38a850f088c56a1c6/kiwisolver-1.4.9-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:90f47e70293fc3688b71271100a1a5453aa9944a81d27ff779c108372cf5567b", size = 1244074, upload-time = "2025-08-10T21:25:42.221Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/bb/f09a1e66dab8984773d13184a10a29fe67125337649d26bdef547024ed6b/kiwisolver-1.4.9-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8fdca1def57a2e88ef339de1737a1449d6dbf5fab184c54a1fca01d541317154", size = 1293036, upload-time = "2025-08-10T21:25:43.801Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/01/11ecf892f201cafda0f68fa59212edaea93e96c37884b747c181303fccd1/kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:9cf554f21be770f5111a1690d42313e140355e687e05cf82cb23d0a721a64a48", size = 2175310, upload-time = "2025-08-10T21:25:45.045Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/5f/bfe11d5b934f500cc004314819ea92427e6e5462706a498c1d4fc052e08f/kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:fc1795ac5cd0510207482c3d1d3ed781143383b8cfd36f5c645f3897ce066220", size = 2270943, upload-time = "2025-08-10T21:25:46.393Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/de/259f786bf71f1e03e73d87e2db1a9a3bcab64d7b4fd780167123161630ad/kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:ccd09f20ccdbbd341b21a67ab50a119b64a403b09288c27481575105283c1586", size = 2440488, upload-time = "2025-08-10T21:25:48.074Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/76/c989c278faf037c4d3421ec07a5c452cd3e09545d6dae7f87c15f54e4edf/kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:540c7c72324d864406a009d72f5d6856f49693db95d1fbb46cf86febef873634", size = 2246787, upload-time = "2025-08-10T21:25:49.442Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/55/c2898d84ca440852e560ca9f2a0d28e6e931ac0849b896d77231929900e7/kiwisolver-1.4.9-cp310-cp310-win_amd64.whl", hash = "sha256:ede8c6d533bc6601a47ad4046080d36b8fc99f81e6f1c17b0ac3c2dc91ac7611", size = 73730, upload-time = "2025-08-10T21:25:51.102Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/09/486d6ac523dd33b80b368247f238125d027964cfacb45c654841e88fb2ae/kiwisolver-1.4.9-cp310-cp310-win_arm64.whl", hash = "sha256:7b4da0d01ac866a57dd61ac258c5607b4cd677f63abaec7b148354d2b2cdd536", size = 65036, upload-time = "2025-08-10T21:25:52.063Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/ab/c80b0d5a9d8a1a65f4f815f2afff9798b12c3b9f31f1d304dd233dd920e2/kiwisolver-1.4.9-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb14a5da6dc7642b0f3a18f13654847cd8b7a2550e2645a5bda677862b03ba16", size = 124167, upload-time = "2025-08-10T21:25:53.403Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c0/27fe1a68a39cf62472a300e2879ffc13c0538546c359b86f149cc19f6ac3/kiwisolver-1.4.9-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:39a219e1c81ae3b103643d2aedb90f1ef22650deb266ff12a19e7773f3e5f089", size = 66579, upload-time = "2025-08-10T21:25:54.79Z" },
+    { url = "https://files.pythonhosted.org/packages/31/a2/a12a503ac1fd4943c50f9822678e8015a790a13b5490354c68afb8489814/kiwisolver-1.4.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2405a7d98604b87f3fc28b1716783534b1b4b8510d8142adca34ee0bc3c87543", size = 65309, upload-time = "2025-08-10T21:25:55.76Z" },
+    { url = "https://files.pythonhosted.org/packages/66/e1/e533435c0be77c3f64040d68d7a657771194a63c279f55573188161e81ca/kiwisolver-1.4.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:dc1ae486f9abcef254b5618dfb4113dd49f94c68e3e027d03cf0143f3f772b61", size = 1435596, upload-time = "2025-08-10T21:25:56.861Z" },
+    { url = "https://files.pythonhosted.org/packages/67/1e/51b73c7347f9aabdc7215aa79e8b15299097dc2f8e67dee2b095faca9cb0/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a1f570ce4d62d718dce3f179ee78dac3b545ac16c0c04bb363b7607a949c0d1", size = 1246548, upload-time = "2025-08-10T21:25:58.246Z" },
+    { url = "https://files.pythonhosted.org/packages/21/aa/72a1c5d1e430294f2d32adb9542719cfb441b5da368d09d268c7757af46c/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb27e7b78d716c591e88e0a09a2139c6577865d7f2e152488c2cc6257f460872", size = 1263618, upload-time = "2025-08-10T21:25:59.857Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/af/db1509a9e79dbf4c260ce0cfa3903ea8945f6240e9e59d1e4deb731b1a40/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:15163165efc2f627eb9687ea5f3a28137217d217ac4024893d753f46bce9de26", size = 1317437, upload-time = "2025-08-10T21:26:01.105Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/f2/3ea5ee5d52abacdd12013a94130436e19969fa183faa1e7c7fbc89e9a42f/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bdee92c56a71d2b24c33a7d4c2856bd6419d017e08caa7802d2963870e315028", size = 2195742, upload-time = "2025-08-10T21:26:02.675Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/9b/1efdd3013c2d9a2566aa6a337e9923a00590c516add9a1e89a768a3eb2fc/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:412f287c55a6f54b0650bd9b6dce5aceddb95864a1a90c87af16979d37c89771", size = 2290810, upload-time = "2025-08-10T21:26:04.009Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/e5/cfdc36109ae4e67361f9bc5b41323648cb24a01b9ade18784657e022e65f/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2c93f00dcba2eea70af2be5f11a830a742fe6b579a1d4e00f47760ef13be247a", size = 2461579, upload-time = "2025-08-10T21:26:05.317Z" },
+    { url = "https://files.pythonhosted.org/packages/62/86/b589e5e86c7610842213994cdea5add00960076bef4ae290c5fa68589cac/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f117e1a089d9411663a3207ba874f31be9ac8eaa5b533787024dc07aeb74f464", size = 2268071, upload-time = "2025-08-10T21:26:06.686Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/c6/f8df8509fd1eee6c622febe54384a96cfaf4d43bf2ccec7a0cc17e4715c9/kiwisolver-1.4.9-cp311-cp311-win_amd64.whl", hash = "sha256:be6a04e6c79819c9a8c2373317d19a96048e5a3f90bec587787e86a1153883c2", size = 73840, upload-time = "2025-08-10T21:26:07.94Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/2d/16e0581daafd147bc11ac53f032a2b45eabac897f42a338d0a13c1e5c436/kiwisolver-1.4.9-cp311-cp311-win_arm64.whl", hash = "sha256:0ae37737256ba2de764ddc12aed4956460277f00c4996d51a197e72f62f5eec7", size = 65159, upload-time = "2025-08-10T21:26:09.048Z" },
+    { url = "https://files.pythonhosted.org/packages/86/c9/13573a747838aeb1c76e3267620daa054f4152444d1f3d1a2324b78255b5/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ac5a486ac389dddcc5bef4f365b6ae3ffff2c433324fb38dd35e3fab7c957999", size = 123686, upload-time = "2025-08-10T21:26:10.034Z" },
+    { url = "https://files.pythonhosted.org/packages/51/ea/2ecf727927f103ffd1739271ca19c424d0e65ea473fbaeea1c014aea93f6/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f2ba92255faa7309d06fe44c3a4a97efe1c8d640c2a79a5ef728b685762a6fd2", size = 66460, upload-time = "2025-08-10T21:26:11.083Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/5a/51f5464373ce2aeb5194508298a508b6f21d3867f499556263c64c621914/kiwisolver-1.4.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a2899935e724dd1074cb568ce7ac0dce28b2cd6ab539c8e001a8578eb106d14", size = 64952, upload-time = "2025-08-10T21:26:12.058Z" },
+    { url = "https://files.pythonhosted.org/packages/70/90/6d240beb0f24b74371762873e9b7f499f1e02166a2d9c5801f4dbf8fa12e/kiwisolver-1.4.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f6008a4919fdbc0b0097089f67a1eb55d950ed7e90ce2cc3e640abadd2757a04", size = 1474756, upload-time = "2025-08-10T21:26:13.096Z" },
+    { url = "https://files.pythonhosted.org/packages/12/42/f36816eaf465220f683fb711efdd1bbf7a7005a2473d0e4ed421389bd26c/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:67bb8b474b4181770f926f7b7d2f8c0248cbcb78b660fdd41a47054b28d2a752", size = 1276404, upload-time = "2025-08-10T21:26:14.457Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/64/bc2de94800adc830c476dce44e9b40fd0809cddeef1fde9fcf0f73da301f/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2327a4a30d3ee07d2fbe2e7933e8a37c591663b96ce42a00bc67461a87d7df77", size = 1294410, upload-time = "2025-08-10T21:26:15.73Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/42/2dc82330a70aa8e55b6d395b11018045e58d0bb00834502bf11509f79091/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a08b491ec91b1d5053ac177afe5290adacf1f0f6307d771ccac5de30592d198", size = 1343631, upload-time = "2025-08-10T21:26:17.045Z" },
+    { url = "https://files.pythonhosted.org/packages/22/fd/f4c67a6ed1aab149ec5a8a401c323cee7a1cbe364381bb6c9c0d564e0e20/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8fc5c867c22b828001b6a38d2eaeb88160bf5783c6cb4a5e440efc981ce286d", size = 2224963, upload-time = "2025-08-10T21:26:18.737Z" },
+    { url = "https://files.pythonhosted.org/packages/45/aa/76720bd4cb3713314677d9ec94dcc21ced3f1baf4830adde5bb9b2430a5f/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3b3115b2581ea35bb6d1f24a4c90af37e5d9b49dcff267eeed14c3893c5b86ab", size = 2321295, upload-time = "2025-08-10T21:26:20.11Z" },
+    { url = "https://files.pythonhosted.org/packages/80/19/d3ec0d9ab711242f56ae0dc2fc5d70e298bb4a1f9dfab44c027668c673a1/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858e4c22fb075920b96a291928cb7dea5644e94c0ee4fcd5af7e865655e4ccf2", size = 2487987, upload-time = "2025-08-10T21:26:21.49Z" },
+    { url = "https://files.pythonhosted.org/packages/39/e9/61e4813b2c97e86b6fdbd4dd824bf72d28bcd8d4849b8084a357bc0dd64d/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ed0fecd28cc62c54b262e3736f8bb2512d8dcfdc2bcf08be5f47f96bf405b145", size = 2291817, upload-time = "2025-08-10T21:26:22.812Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/41/85d82b0291db7504da3c2defe35c9a8a5c9803a730f297bd823d11d5fb77/kiwisolver-1.4.9-cp312-cp312-win_amd64.whl", hash = "sha256:f68208a520c3d86ea51acf688a3e3002615a7f0238002cccc17affecc86a8a54", size = 73895, upload-time = "2025-08-10T21:26:24.37Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/92/5f3068cf15ee5cb624a0c7596e67e2a0bb2adee33f71c379054a491d07da/kiwisolver-1.4.9-cp312-cp312-win_arm64.whl", hash = "sha256:2c1a4f57df73965f3f14df20b80ee29e6a7930a57d2d9e8491a25f676e197c60", size = 64992, upload-time = "2025-08-10T21:26:25.732Z" },
+    { url = "https://files.pythonhosted.org/packages/31/c1/c2686cda909742ab66c7388e9a1a8521a59eb89f8bcfbee28fc980d07e24/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5d0432ccf1c7ab14f9949eec60c5d1f924f17c037e9f8b33352fa05799359b8", size = 123681, upload-time = "2025-08-10T21:26:26.725Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/f0/f44f50c9f5b1a1860261092e3bc91ecdc9acda848a8b8c6abfda4a24dd5c/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efb3a45b35622bb6c16dbfab491a8f5a391fe0e9d45ef32f4df85658232ca0e2", size = 66464, upload-time = "2025-08-10T21:26:27.733Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/7a/9d90a151f558e29c3936b8a47ac770235f436f2120aca41a6d5f3d62ae8d/kiwisolver-1.4.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1a12cf6398e8a0a001a059747a1cbf24705e18fe413bc22de7b3d15c67cffe3f", size = 64961, upload-time = "2025-08-10T21:26:28.729Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/e9/f218a2cb3a9ffbe324ca29a9e399fa2d2866d7f348ec3a88df87fc248fc5/kiwisolver-1.4.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b67e6efbf68e077dd71d1a6b37e43e1a99d0bff1a3d51867d45ee8908b931098", size = 1474607, upload-time = "2025-08-10T21:26:29.798Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/28/aac26d4c882f14de59041636292bc838db8961373825df23b8eeb807e198/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5656aa670507437af0207645273ccdfee4f14bacd7f7c67a4306d0dcaeaf6eed", size = 1276546, upload-time = "2025-08-10T21:26:31.401Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/ad/8bfc1c93d4cc565e5069162f610ba2f48ff39b7de4b5b8d93f69f30c4bed/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bfc08add558155345129c7803b3671cf195e6a56e7a12f3dde7c57d9b417f525", size = 1294482, upload-time = "2025-08-10T21:26:32.721Z" },
+    { url = "https://files.pythonhosted.org/packages/da/f1/6aca55ff798901d8ce403206d00e033191f63d82dd708a186e0ed2067e9c/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:40092754720b174e6ccf9e845d0d8c7d8e12c3d71e7fc35f55f3813e96376f78", size = 1343720, upload-time = "2025-08-10T21:26:34.032Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/91/eed031876c595c81d90d0f6fc681ece250e14bf6998c3d7c419466b523b7/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:497d05f29a1300d14e02e6441cf0f5ee81c1ff5a304b0d9fb77423974684e08b", size = 2224907, upload-time = "2025-08-10T21:26:35.824Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/ec/4d1925f2e49617b9cca9c34bfa11adefad49d00db038e692a559454dfb2e/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:bdd1a81a1860476eb41ac4bc1e07b3f07259e6d55bbf739b79c8aaedcf512799", size = 2321334, upload-time = "2025-08-10T21:26:37.534Z" },
+    { url = "https://files.pythonhosted.org/packages/43/cb/450cd4499356f68802750c6ddc18647b8ea01ffa28f50d20598e0befe6e9/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:e6b93f13371d341afee3be9f7c5964e3fe61d5fa30f6a30eb49856935dfe4fc3", size = 2488313, upload-time = "2025-08-10T21:26:39.191Z" },
+    { url = "https://files.pythonhosted.org/packages/71/67/fc76242bd99f885651128a5d4fa6083e5524694b7c88b489b1b55fdc491d/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d75aa530ccfaa593da12834b86a0724f58bff12706659baa9227c2ccaa06264c", size = 2291970, upload-time = "2025-08-10T21:26:40.828Z" },
+    { url = "https://files.pythonhosted.org/packages/75/bd/f1a5d894000941739f2ae1b65a32892349423ad49c2e6d0771d0bad3fae4/kiwisolver-1.4.9-cp313-cp313-win_amd64.whl", hash = "sha256:dd0a578400839256df88c16abddf9ba14813ec5f21362e1fe65022e00c883d4d", size = 73894, upload-time = "2025-08-10T21:26:42.33Z" },
+    { url = "https://files.pythonhosted.org/packages/95/38/dce480814d25b99a391abbddadc78f7c117c6da34be68ca8b02d5848b424/kiwisolver-1.4.9-cp313-cp313-win_arm64.whl", hash = "sha256:d4188e73af84ca82468f09cadc5ac4db578109e52acb4518d8154698d3a87ca2", size = 64995, upload-time = "2025-08-10T21:26:43.889Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/37/7d218ce5d92dadc5ebdd9070d903e0c7cf7edfe03f179433ac4d13ce659c/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5a0f2724dfd4e3b3ac5a82436a8e6fd16baa7d507117e4279b660fe8ca38a3a1", size = 126510, upload-time = "2025-08-10T21:26:44.915Z" },
+    { url = "https://files.pythonhosted.org/packages/23/b0/e85a2b48233daef4b648fb657ebbb6f8367696a2d9548a00b4ee0eb67803/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:1b11d6a633e4ed84fc0ddafd4ebfd8ea49b3f25082c04ad12b8315c11d504dc1", size = 67903, upload-time = "2025-08-10T21:26:45.934Z" },
+    { url = "https://files.pythonhosted.org/packages/44/98/f2425bc0113ad7de24da6bb4dae1343476e95e1d738be7c04d31a5d037fd/kiwisolver-1.4.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61874cdb0a36016354853593cffc38e56fc9ca5aa97d2c05d3dcf6922cd55a11", size = 66402, upload-time = "2025-08-10T21:26:47.101Z" },
+    { url = "https://files.pythonhosted.org/packages/98/d8/594657886df9f34c4177cc353cc28ca7e6e5eb562d37ccc233bff43bbe2a/kiwisolver-1.4.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:60c439763a969a6af93b4881db0eed8fadf93ee98e18cbc35bc8da868d0c4f0c", size = 1582135, upload-time = "2025-08-10T21:26:48.665Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/c6/38a115b7170f8b306fc929e166340c24958347308ea3012c2b44e7e295db/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92a2f997387a1b79a75e7803aa7ded2cfbe2823852ccf1ba3bcf613b62ae3197", size = 1389409, upload-time = "2025-08-10T21:26:50.335Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/3b/e04883dace81f24a568bcee6eb3001da4ba05114afa622ec9b6fafdc1f5e/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31d512c812daea6d8b3be3b2bfcbeb091dbb09177706569bcfc6240dcf8b41c", size = 1401763, upload-time = "2025-08-10T21:26:51.867Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/80/20ace48e33408947af49d7d15c341eaee69e4e0304aab4b7660e234d6288/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:52a15b0f35dad39862d376df10c5230155243a2c1a436e39eb55623ccbd68185", size = 1453643, upload-time = "2025-08-10T21:26:53.592Z" },
+    { url = "https://files.pythonhosted.org/packages/64/31/6ce4380a4cd1f515bdda976a1e90e547ccd47b67a1546d63884463c92ca9/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a30fd6fdef1430fd9e1ba7b3398b5ee4e2887783917a687d86ba69985fb08748", size = 2330818, upload-time = "2025-08-10T21:26:55.051Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/e9/3f3fcba3bcc7432c795b82646306e822f3fd74df0ee81f0fa067a1f95668/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cc9617b46837c6468197b5945e196ee9ca43057bb7d9d1ae688101e4e1dddf64", size = 2419963, upload-time = "2025-08-10T21:26:56.421Z" },
+    { url = "https://files.pythonhosted.org/packages/99/43/7320c50e4133575c66e9f7dadead35ab22d7c012a3b09bb35647792b2a6d/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:0ab74e19f6a2b027ea4f845a78827969af45ce790e6cb3e1ebab71bdf9f215ff", size = 2594639, upload-time = "2025-08-10T21:26:57.882Z" },
+    { url = "https://files.pythonhosted.org/packages/65/d6/17ae4a270d4a987ef8a385b906d2bdfc9fce502d6dc0d3aea865b47f548c/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dba5ee5d3981160c28d5490f0d1b7ed730c22470ff7f6cc26cfcfaacb9896a07", size = 2391741, upload-time = "2025-08-10T21:26:59.237Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/8f/8f6f491d595a9e5912971f3f863d81baddccc8a4d0c3749d6a0dd9ffc9df/kiwisolver-1.4.9-cp313-cp313t-win_arm64.whl", hash = "sha256:0749fd8f4218ad2e851e11cc4dc05c7cbc0cbc4267bdfdb31782e65aace4ee9c", size = 68646, upload-time = "2025-08-10T21:27:00.52Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/63/fde392691690f55b38d5dd7b3710f5353bf7a8e52de93a22968801ab8978/kiwisolver-1.4.9-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:4d1d9e582ad4d63062d34077a9a1e9f3c34088a2ec5135b1f7190c07cf366527", size = 60183, upload-time = "2025-08-10T21:27:37.669Z" },
+    { url = "https://files.pythonhosted.org/packages/27/b1/6aad34edfdb7cced27f371866f211332bba215bfd918ad3322a58f480d8b/kiwisolver-1.4.9-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:deed0c7258ceb4c44ad5ec7d9918f9f14fd05b2be86378d86cf50e63d1e7b771", size = 58675, upload-time = "2025-08-10T21:27:39.031Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/1a/23d855a702bb35a76faed5ae2ba3de57d323f48b1f6b17ee2176c4849463/kiwisolver-1.4.9-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0a590506f303f512dff6b7f75fd2fd18e16943efee932008fe7140e5fa91d80e", size = 80277, upload-time = "2025-08-10T21:27:40.129Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/5b/5239e3c2b8fb5afa1e8508f721bb77325f740ab6994d963e61b2b7abcc1e/kiwisolver-1.4.9-pp310-pypy310_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e09c2279a4d01f099f52d5c4b3d9e208e91edcbd1a175c9662a8b16e000fece9", size = 77994, upload-time = "2025-08-10T21:27:41.181Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/1c/5d4d468fb16f8410e596ed0eac02d2c68752aa7dc92997fe9d60a7147665/kiwisolver-1.4.9-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:c9e7cdf45d594ee04d5be1b24dd9d49f3d1590959b2271fb30b5ca2b262c00fb", size = 73744, upload-time = "2025-08-10T21:27:42.254Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/0f/36d89194b5a32c054ce93e586d4049b6c2c22887b0eb229c61c68afd3078/kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:720e05574713db64c356e86732c0f3c5252818d05f9df320f0ad8380641acea5", size = 60104, upload-time = "2025-08-10T21:27:43.287Z" },
+    { url = "https://files.pythonhosted.org/packages/52/ba/4ed75f59e4658fd21fe7dde1fee0ac397c678ec3befba3fe6482d987af87/kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:17680d737d5335b552994a2008fab4c851bcd7de33094a82067ef3a576ff02fa", size = 58592, upload-time = "2025-08-10T21:27:44.314Z" },
+    { url = "https://files.pythonhosted.org/packages/33/01/a8ea7c5ea32a9b45ceeaee051a04c8ed4320f5add3c51bfa20879b765b70/kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:85b5352f94e490c028926ea567fc569c52ec79ce131dadb968d3853e809518c2", size = 80281, upload-time = "2025-08-10T21:27:45.369Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/dbd2ecdce306f1d07a1aaf324817ee993aab7aee9db47ceac757deabafbe/kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:464415881e4801295659462c49461a24fb107c140de781d55518c4b80cb6790f", size = 78009, upload-time = "2025-08-10T21:27:46.376Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e9/0d4add7873a73e462aeb45c036a2dead2562b825aa46ba326727b3f31016/kiwisolver-1.4.9-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:fb940820c63a9590d31d88b815e7a3aa5915cad3ce735ab45f0c730b39547de1", size = 73929, upload-time = "2025-08-10T21:27:48.236Z" },
+]
+
+[[package]]
+name = "latexcodec"
+version = "3.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/27/dd/4270b2c5e2ee49316c3859e62293bd2ea8e382339d63ab7bbe9f39c0ec3b/latexcodec-3.0.1.tar.gz", hash = "sha256:e78a6911cd72f9dec35031c6ec23584de6842bfbc4610a9678868d14cdfb0357", size = 31222, upload-time = "2025-06-17T18:47:34.051Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b5/40/23569737873cc9637fd488606347e9dd92b9fa37ba4fcda1f98ee5219a97/latexcodec-3.0.1-py3-none-any.whl", hash = "sha256:a9eb8200bff693f0437a69581f7579eb6bca25c4193515c09900ce76451e452e", size = 18532, upload-time = "2025-06-17T18:47:30.726Z" },
+]
+
+[[package]]
+name = "lxml"
+version = "6.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/28/30/9abc9e34c657c33834eaf6cd02124c61bdf5944d802aa48e69be8da3585d/lxml-6.1.0.tar.gz", hash = "sha256:bfd57d8008c4965709a919c3e9a98f76c2c7cb319086b3d26858250620023b13", size = 4197006, upload-time = "2026-04-18T04:32:51.613Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/02/6e/ee8fc0e01202eb3dd2b9e1ea4f0910d72425d35c66187c63931d7a3ea73f/lxml-6.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:41dcc4c7b10484257cbd6c37b83ddb26df2b0e5aff5ac00d095689015af868ec", size = 8540733, upload-time = "2026-04-18T04:27:33.185Z" },
+    { url = "https://files.pythonhosted.org/packages/54/e8/325fe9b942824c773dffe1baf0c35b046a763851fdff4393af4450bceeb7/lxml-6.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a31286dbb5e74c8e9a5344465b77ab4c5bd511a253b355b5ca2fae7e579fafec", size = 4602805, upload-time = "2026-04-18T04:27:36.097Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/81/221aa3ea4a40370bb0358fa454cbe7e5a837e522f7630c24dfef3f9a73b0/lxml-6.1.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1bc4cc83fb7f66ffb16f74d6dd0162e144333fc36ebcce32246f80c8735b2551", size = 5002652, upload-time = "2026-04-18T04:27:30.603Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/e1/fdbfb9019542f1875c093576df7f37adc2983c8ba7ecf17e5f14490bc107/lxml-6.1.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:20cf4d0651987c906a2f5cba4e3a8d6ba4bfdf973cfe2a96c0d6053888ea2ecd", size = 5155332, upload-time = "2026-04-18T04:27:33.507Z" },
+    { url = "https://files.pythonhosted.org/packages/56/b1/4087c782fff397cd03abf9c551069be59bb04a7e548c50fb7b9c4cdaca28/lxml-6.1.0-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ffb34ea45a82dd637c2c97ae1bbb920850c1e59bcae79ce1c15af531d83e7215", size = 5057226, upload-time = "2026-04-18T04:27:37.567Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/66/516c79dec8417f3a972327330254c0b5fac93d5c3ecfd8a5b43650a5a4d9/lxml-6.1.0-cp310-cp310-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a1d9b99e5b2597e4f5aed2484fef835256fa1b68a19e4265c97628ef4bf8bcf4", size = 5287588, upload-time = "2026-04-18T04:27:41.4Z" },
+    { url = "https://files.pythonhosted.org/packages/94/1d/e578f4cbeb42b9df9f29b0d44a45a7cdfa3a5ae300dd59ec68e3602d29bb/lxml-6.1.0-cp310-cp310-manylinux_2_28_i686.whl", hash = "sha256:d43aa26dcda363f21e79afa0668f5029ed7394b3bb8c92a6927a3d34e8b610ea", size = 5412438, upload-time = "2026-04-18T04:27:45.589Z" },
+    { url = "https://files.pythonhosted.org/packages/47/5b/2aa68307d6d15959e84d4882f9c04f2da63127eac463e1594166f681ef77/lxml-6.1.0-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:6262b87f9e5c1e5fe501d6c153247289af42eb44ad7660b9b3de17baaf92d6f6", size = 4770997, upload-time = "2026-04-18T04:27:49.853Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/c9/3e51fc1228310a836b4eb32595ae00154ab12197fca944676a3ab3b163ea/lxml-6.1.0-cp310-cp310-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d1392c569c032f78a11a25d1de1c43fff13294c793b39e19d84fade3045cbbc3", size = 5359678, upload-time = "2026-04-18T04:31:56.184Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/91/ab8bc834f977fbbd310e697b120787c153db026f9151e02a88d2645d4e5b/lxml-6.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:045e387d1f4f42a418380930fa3f45c73c9b392faf67e495e58902e68e8f44a7", size = 5107890, upload-time = "2026-04-18T04:32:00.387Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/10/8a143cfa3ac99cb5b0523ff6d0429a9c9dddf25ffeae09caa3866c7964d9/lxml-6.1.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:9f93d5b8b07f73e8c77e3c6556a3db269918390c804b5e5fcdd4858232cc8f16", size = 4803977, upload-time = "2026-04-18T04:32:05.099Z" },
+    { url = "https://files.pythonhosted.org/packages/45/fd/ee02faf52fa39c2fe32f824628958b9aa86dff21343dc3161f0e3c6ccd15/lxml-6.1.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:de550d129f18d8ab819651ffe4f38b1b713c7e116707de3c0c6400d0ef34fbc1", size = 5350277, upload-time = "2026-04-18T04:32:09.176Z" },
+    { url = "https://files.pythonhosted.org/packages/85/8c/b3481364b8554b5d36d540189a87fc71e94b0b01c24f8f152bd662dd2e45/lxml-6.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c08da09dc003c9e8c70e06b53a11db6fb3b250c21c4236b03c7d7b443c318e7a", size = 5309717, upload-time = "2026-04-18T04:32:13.303Z" },
+    { url = "https://files.pythonhosted.org/packages/74/e8/a6b21927077a9127afa17473b6576b322616f34ac50ee4f577e763b75ec0/lxml-6.1.0-cp310-cp310-win32.whl", hash = "sha256:37448bf9c7d7adfc5254763901e2bbd6bb876228dfc1fc7f66e58c06368a7544", size = 3598491, upload-time = "2026-04-18T04:27:24.288Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/82/14dea800d041274d96c07d49ff9191f011d1427450850de19bf541e2cc12/lxml-6.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:2593a0a6621545b9095b71ad74ed4226eba438a7d9fc3712a99bdb15508cf93a", size = 4020906, upload-time = "2026-04-18T04:27:27.53Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/ba/d3539aaf4d9d21456b9a7b902816623227d05d63e7c5aafd8834c4b9bed6/lxml-6.1.0-cp310-cp310-win_arm64.whl", hash = "sha256:e80807d72f96b96ad5588cb85c75616e4f2795a7737d4630784c51497beb7776", size = 3667787, upload-time = "2026-04-18T04:27:29.407Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/5d/3bccad330292946f97962df9d5f2d3ae129cce6e212732a781e856b91e07/lxml-6.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:cec05be8c876f92a5aa07b01d60bbb4d11cfbdd654cad0561c0d7b5c043a61b9", size = 8526232, upload-time = "2026-04-18T04:27:40.389Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/51/adc8826570a112f83bb4ddb3a2ab510bbc2ccd62c1b9fe1f34fae2d90b57/lxml-6.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9c03e048b6ce8e77b09c734e931584894ecd58d08296804ca2d0b184c933ce50", size = 4595448, upload-time = "2026-04-18T04:27:44.208Z" },
+    { url = "https://files.pythonhosted.org/packages/54/84/5a9ec07cbe1d2334a6465f863b949a520d2699a755738986dcd3b6b89e3f/lxml-6.1.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:942454ff253da14218f972b23dc72fa4edf6c943f37edd19cd697618b626fac5", size = 4923771, upload-time = "2026-04-18T04:32:17.402Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/23/851cfa33b6b38adb628e45ad51fb27105fa34b2b3ba9d1d4aa7a9428dfe0/lxml-6.1.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d036ee7b99d5148072ac7c9b847193decdfeac633db350363f7bce4fff108f0e", size = 5068101, upload-time = "2026-04-18T04:32:21.437Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/38/41bf99c2023c6b79916ba057d83e9db21d642f473cac210201222882d38b/lxml-6.1.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ae5d8d5427f3cc317e7950f2da7ad276df0cfa37b8de2f5658959e618ea8512", size = 5002573, upload-time = "2026-04-18T04:32:25.373Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/20/053aa10bdc39747e1e923ce2d45413075e84f70a136045bb09e5eaca41d3/lxml-6.1.0-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:363e47283bde87051b821826e71dde47f107e08614e1aa312ba0c5711e77738c", size = 5202816, upload-time = "2026-04-18T04:32:29.393Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/da/bc710fad8bf04b93baee752c192eaa2210cd3a84f969d0be7830fea55802/lxml-6.1.0-cp311-cp311-manylinux_2_28_i686.whl", hash = "sha256:f504d861d9f2a8f94020130adac88d66de93841707a23a86244263d1e54682f5", size = 5329999, upload-time = "2026-04-18T04:32:34.019Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/cb/bf035dedbdf7fab49411aa52e4236f3445e98d38647d85419e6c0d2806b9/lxml-6.1.0-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:23a5dc68e08ed13331d61815c08f260f46b4a60fdd1640bbeb82cf89a9d90289", size = 4659643, upload-time = "2026-04-18T04:32:37.932Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/4f/22be31f33727a5e4c7b01b0a874503026e50329b259d3587e0b923cf964b/lxml-6.1.0-cp311-cp311-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f15401d8d3dbf239e23c818afc10c7207f7b95f9a307e092122b6f86dd43209a", size = 5265963, upload-time = "2026-04-18T04:32:41.881Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/2b/d44d0e5c79226017f4ab8c87a802ebe4f89f97e6585a8e4166dffcdd7b6e/lxml-6.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fcf3da95e93349e0647d48d4b36a12783105bcc74cb0c416952f9988410846a3", size = 5045444, upload-time = "2026-04-18T04:32:44.512Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/c3/3f034fec1594c331a6dbf9491238fdcc9d66f68cc529e109ec75b97197e1/lxml-6.1.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:0d082495c5fcf426e425a6e28daaba1fcb6d8f854a4ff01effb1f1f381203eb9", size = 4712703, upload-time = "2026-04-18T04:32:47.16Z" },
+    { url = "https://files.pythonhosted.org/packages/12/16/0b83fccc158218aca75a7aa33e97441df737950734246b9fffa39301603d/lxml-6.1.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:e3c4f84b24a1fcba435157d111c4b755099c6ff00a3daee1ad281817de75ed11", size = 5252745, upload-time = "2026-04-18T04:32:50.427Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/ee/12e6c1b39a77666c02eaa77f94a870aaf63c4ac3a497b2d52319448b01c6/lxml-6.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:976a6b39b1b13e8c354ad8d3f261f3a4ac6609518af91bdb5094760a08f132c4", size = 5226822, upload-time = "2026-04-18T04:32:53.437Z" },
+    { url = "https://files.pythonhosted.org/packages/34/20/c7852904858b4723af01d2fc14b5d38ff57cb92f01934a127ebd9a9e51aa/lxml-6.1.0-cp311-cp311-win32.whl", hash = "sha256:857efde87d365706590847b916baff69c0bc9252dc5af030e378c9800c0b10e3", size = 3594026, upload-time = "2026-04-18T04:27:31.903Z" },
+    { url = "https://files.pythonhosted.org/packages/02/05/d60c732b56da5085175c07c74b2df4e6d181b0c9a61e1691474f06ef4b39/lxml-6.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:183bfb45a493081943be7ea2b5adfc2b611e1cf377cefa8b8a8be404f45ef9a7", size = 4025114, upload-time = "2026-04-18T04:27:34.077Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/df/c84dcc175fd690823436d15b41cb920cd5ba5e14cd8bfb00949d5903b320/lxml-6.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:19f4164243fc206d12ed3d866e80e74f5bc3627966520da1a5f97e42c32a3f39", size = 3667742, upload-time = "2026-04-18T04:27:38.45Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d4/9326838b59dc36dfae42eec9656b97520f9997eee1de47b8316aaeed169c/lxml-6.1.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d2f17a16cd8751e8eb233a7e41aecdf8e511712e00088bf9be455f604cd0d28d", size = 8570663, upload-time = "2026-04-18T04:27:48.253Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/a4/053745ce1f8303ccbb788b86c0db3a91b973675cefc42566a188637b7c40/lxml-6.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f0cea5b1d3e6e77d71bd2b9972eb2446221a69dc52bb0b9c3c6f6e5700592d93", size = 4624024, upload-time = "2026-04-18T04:27:52.594Z" },
+    { url = "https://files.pythonhosted.org/packages/90/97/a517944b20f8fd0932ad2109482bee4e29fe721416387a363306667941f6/lxml-6.1.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fc46da94826188ed45cb53bd8e3fc076ae22675aea2087843d4735627f867c6d", size = 4930895, upload-time = "2026-04-18T04:32:56.29Z" },
+    { url = "https://files.pythonhosted.org/packages/94/7c/e08a970727d556caa040a44773c7b7e3ad0f0d73dedc863543e9a8b931f2/lxml-6.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9147d8e386ec3b82c3b15d88927f734f565b0aaadef7def562b853adca45784a", size = 5093820, upload-time = "2026-04-18T04:32:58.94Z" },
+    { url = "https://files.pythonhosted.org/packages/88/ee/2a5c2aa2c32016a226ca25d3e1056a8102ea6e1fe308bf50213586635400/lxml-6.1.0-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5715e0e28736a070f3f34a7ccc09e2fdcba0e3060abbcf61a1a5718ff6d6b105", size = 5005790, upload-time = "2026-04-18T04:33:01.272Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/38/a0db9be8f38ad6043ab9429487c128dd1d30f07956ef43040402f8da49e8/lxml-6.1.0-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4937460dc5df0cdd2f06a86c285c28afda06aefa3af949f9477d3e8df430c485", size = 5630827, upload-time = "2026-04-18T04:33:04.036Z" },
+    { url = "https://files.pythonhosted.org/packages/31/ba/3c13d3fc24b7cacf675f808a3a1baabf43a30d0cd24c98f94548e9aa58eb/lxml-6.1.0-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bc783ee3147e60a25aa0445ea82b3e8aabb83b240f2b95d32cb75587ff781814", size = 5240445, upload-time = "2026-04-18T04:33:06.87Z" },
+    { url = "https://files.pythonhosted.org/packages/55/ba/eeef4ccba09b2212fe239f46c1692a98db1878e0872ae320756488878a94/lxml-6.1.0-cp312-cp312-manylinux_2_28_i686.whl", hash = "sha256:40d9189f80075f2e1f88db21ef815a2b17b28adf8e50aaf5c789bfe737027f32", size = 5350121, upload-time = "2026-04-18T04:33:09.365Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/01/1da87c7b587c38d0cbe77a01aae3b9c1c49ed47d76918ef3db8fc151b1ca/lxml-6.1.0-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:05b9b8787e35bec69e68daf4952b2e6dfcfb0db7ecf1a06f8cdfbbac4eb71aad", size = 4694949, upload-time = "2026-04-18T04:33:11.628Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/88/7db0fe66d5aaf128443ee1623dec3db1576f3e4c17751ec0ef5866468590/lxml-6.1.0-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0f0f08beb0182e3e9a86fae124b3c47a7b41b7b69b225e1377db983802404e54", size = 5243901, upload-time = "2026-04-18T04:33:13.95Z" },
+    { url = "https://files.pythonhosted.org/packages/00/a8/1346726af7d1f6fca1f11223ba34001462b0a3660416986d37641708d57c/lxml-6.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73becf6d8c81d4c76b1014dbd3584cb26d904492dcf73ca85dc8bff08dcd6d2d", size = 5048054, upload-time = "2026-04-18T04:33:16.965Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/b7/85057012f035d1a0c87e02f8c723ca3c3e6e0728bcf4cb62080b21b1c1e3/lxml-6.1.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:1ae225f66e5938f4fa29d37e009a3bb3b13032ac57eb4eb42afa44f6e4054e69", size = 4777324, upload-time = "2026-04-18T04:33:19.832Z" },
+    { url = "https://files.pythonhosted.org/packages/75/6c/ad2f94a91073ef570f33718040e8e160d5fb93331cf1ab3ca1323f939e2d/lxml-6.1.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:690022c7fae793b0489aa68a658822cea83e0d5933781811cabbf5ea3bcfe73d", size = 5645702, upload-time = "2026-04-18T04:33:22.436Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/89/0bb6c0bd549c19004c60eea9dc554dd78fd647b72314ef25d460e0d208c6/lxml-6.1.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:63aeafc26aac0be8aff14af7871249e87ea1319be92090bfd632ec68e03b16a5", size = 5232901, upload-time = "2026-04-18T04:33:26.21Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/d9/d609a11fb567da9399f525193e2b49847b5a409cdebe737f06a8b7126bdc/lxml-6.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:264c605ab9c0e4aa1a679636f4582c4d3313700009fac3ec9c3412ed0d8f3e1d", size = 5261333, upload-time = "2026-04-18T04:33:28.984Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/3a/ac3f99ec8ac93089e7dd556f279e0d14c24de0a74a507e143a2e4b496e7c/lxml-6.1.0-cp312-cp312-win32.whl", hash = "sha256:56971379bc5ee8037c5a0f09fa88f66cdb7d37c3e38af3e45cf539f41131ac1f", size = 3596289, upload-time = "2026-04-18T04:27:42.819Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/a7/0a915557538593cb1bbeedcd40e13c7a261822c26fecbbdb71dad0c2f540/lxml-6.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:bba078de0031c219e5dd06cf3e6bf8fb8e6e64a77819b358f53bb132e3e03366", size = 3997059, upload-time = "2026-04-18T04:27:46.764Z" },
+    { url = "https://files.pythonhosted.org/packages/92/96/a5dc078cf0126fbfbc35611d77ecd5da80054b5893e28fb213a5613b9e1d/lxml-6.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:c3592631e652afa34999a088f98ba7dfc7d6aff0d535c410bea77a71743f3819", size = 3659552, upload-time = "2026-04-18T04:27:51.133Z" },
+    { url = "https://files.pythonhosted.org/packages/08/03/69347590f1cf4a6d5a4944bb6099e6d37f334784f16062234e1f892fdb1d/lxml-6.1.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a0092f2b107b69601adf562a57c956fbb596e05e3e6651cabd3054113b007e45", size = 8559689, upload-time = "2026-04-18T04:31:57.785Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/58/25e00bb40b185c974cfe156c110474d9a8a8390d5f7c92a4e328189bb60e/lxml-6.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:fc7140d7a7386e6b545d41b7358f4d02b656d4053f5fa6859f92f4b9c2572c4d", size = 4617892, upload-time = "2026-04-18T04:32:01.78Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/54/92ad98a94ac318dc4f97aaac22ff8d1b94212b2ae8af5b6e9b354bf825f7/lxml-6.1.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:419c58fc92cc3a2c3fa5f78c63dbf5da70c1fa9c1b25f25727ecee89a96c7de2", size = 4923489, upload-time = "2026-04-18T04:33:31.401Z" },
+    { url = "https://files.pythonhosted.org/packages/15/3b/a20aecfab42bdf4f9b390590d345857ad3ffd7c51988d1c89c53a0c73faf/lxml-6.1.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:37fabd1452852636cf38ecdcc9dd5ca4bba7a35d6c53fa09725deeb894a87491", size = 5082162, upload-time = "2026-04-18T04:33:34.262Z" },
+    { url = "https://files.pythonhosted.org/packages/45/26/2cdb3d281ac1bd175603e290cbe4bad6eff127c0f8de90bafd6f8548f0fd/lxml-6.1.0-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a2853c8b2170cc6cd54a6b4d50d2c1a8a7aeca201f23804b4898525c7a152cfc", size = 4993247, upload-time = "2026-04-18T04:33:36.674Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/05/d735aef963740022a08185c84821f689fc903acb3d50326e6b1e9886cc22/lxml-6.1.0-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8e369cbd690e788c8d15e56222d91a09c6a417f49cbc543040cba0fe2e25a79e", size = 5613042, upload-time = "2026-04-18T04:33:39.205Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/b8/ead7c10efff731738c72e59ed6eb5791854879fbed7ae98781a12006263a/lxml-6.1.0-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e69aa6805905807186eb00e66c6d97a935c928275182eb02ee40ba00da9623b2", size = 5228304, upload-time = "2026-04-18T04:33:41.647Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/10/e9842d2ec322ea65f0a7270aa0315a53abed06058b88ef1b027f620e7a5f/lxml-6.1.0-cp313-cp313-manylinux_2_28_i686.whl", hash = "sha256:4bd1bdb8a9e0e2dd229de19b5f8aebac80e916921b4b2c6ef8a52bc131d0c1f9", size = 5341578, upload-time = "2026-04-18T04:33:44.596Z" },
+    { url = "https://files.pythonhosted.org/packages/89/54/40d9403d7c2775fa7301d3ddd3464689bfe9ba71acc17dfff777071b4fdc/lxml-6.1.0-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:cbd7b79cdcb4986ad78a2662625882747f09db5e4cd7b2ae178a88c9c51b3dfe", size = 4700209, upload-time = "2026-04-18T04:33:47.552Z" },
+    { url = "https://files.pythonhosted.org/packages/85/b2/bbdcc2cf45dfc7dfffef4fd97e5c47b15919b6a365247d95d6f684ef5e82/lxml-6.1.0-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:43e4d297f11080ec9d64a4b1ad7ac02b4484c9f0e2179d9c4ef78e886e747b88", size = 5232365, upload-time = "2026-04-18T04:33:50.249Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5a/b06875665e53aaba7127611a7bed3b7b9658e20b22bc2dd217a0b7ab0091/lxml-6.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cc16682cc987a3da00aa56a3aa3075b08edb10d9b1e476938cfdbee8f3b67181", size = 5043654, upload-time = "2026-04-18T04:33:52.71Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/9c/e71a069d09641c1a7abeb30e693f828c7c90a41cbe3d650b2d734d876f85/lxml-6.1.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:d6d8efe71429635f0559579092bb5e60560d7b9115ee38c4adbea35632e7fa24", size = 4769326, upload-time = "2026-04-18T04:33:55.244Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/06/7a9cd84b3d4ed79adf35f874750abb697dec0b4a81a836037b36e47c091a/lxml-6.1.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7e39ab3a28af7784e206d8606ec0e4bcad0190f63a492bca95e94e5a4aef7f6e", size = 5635879, upload-time = "2026-04-18T04:33:58.509Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/f0/9d57916befc1e54c451712c7ee48e9e74e80ae4d03bdce49914e0aee42cd/lxml-6.1.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:9eb667bf50856c4a58145f8ca2d5e5be160191e79eb9e30855a476191b3c3495", size = 5224048, upload-time = "2026-04-18T04:34:00.943Z" },
+    { url = "https://files.pythonhosted.org/packages/99/75/90c4eefda0c08c92221fe0753db2d6699a4c628f76ff4465ec20dea84cc1/lxml-6.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7f4a77d6f7edf9230cee3e1f7f6764722a41604ee5681844f18db9a81ea0ec33", size = 5250241, upload-time = "2026-04-18T04:34:03.365Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/73/16596f7e4e38fa33084b9ccbccc22a15f82a290a055126f2c1541236d2ff/lxml-6.1.0-cp313-cp313-win32.whl", hash = "sha256:28902146ffbe5222df411c5d19e5352490122e14447e98cd118907ee3fd6ee62", size = 3596938, upload-time = "2026-04-18T04:31:56.206Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/63/981401c5680c1eb30893f00a19641ac80db5d1e7086c62cb4b13ed813038/lxml-6.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:4a1503c56e4e2b38dc76f2f2da7bae69670c0f1933e27cfa34b2fa5876410b16", size = 3995728, upload-time = "2026-04-18T04:31:58.763Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/e8/c358a38ac3e541d16a1b527e4e9cb78c0419b0506a070ace11777e5e8404/lxml-6.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:e0af85773850417d994d019741239b901b22c6680206f46a34766926e466141d", size = 3658372, upload-time = "2026-04-18T04:32:03.629Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/88/55143966481409b1740a3ac669e611055f49efd68087a5ce41582325db3e/lxml-6.1.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:546b66c0dd1bb8d9fa89d7123e5fa19a8aff3a1f2141eb22df96112afb17b842", size = 3930134, upload-time = "2026-04-18T04:32:35.008Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/97/28b985c2983938d3cb696dd5501423afb90a8c3e869ef5d3c62569282c0f/lxml-6.1.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5cfa1a34df366d9dc0d5eaf420f4cf2bb1e1bebe1066d1c2fc28c179f8a4004c", size = 4210749, upload-time = "2026-04-18T04:36:03.626Z" },
+    { url = "https://files.pythonhosted.org/packages/29/67/dfab2b7d58214921935ccea7ce9b3df9b7d46f305d12f0f532ac7cf6b804/lxml-6.1.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:db88156fcf544cdbf0d95588051515cfdfd4c876fc66444eb98bceb5d6db76de", size = 4318463, upload-time = "2026-04-18T04:36:06.309Z" },
+    { url = "https://files.pythonhosted.org/packages/32/a2/4ac7eb32a4d997dd352c32c32399aae27b3f268d440e6f9cfa405b575d2f/lxml-6.1.0-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:07f98f5496f96bf724b1e3c933c107f0cbf2745db18c03d2e13a291c3afd2635", size = 4251124, upload-time = "2026-04-18T04:36:09.056Z" },
+    { url = "https://files.pythonhosted.org/packages/33/ef/d6abd850bb4822f9b720cfe36b547a558e694881010ff7d012191e8769c6/lxml-6.1.0-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4642e04449a1e164b5ff71ffd901ddb772dfabf5c9adf1b7be5dffe1212bc037", size = 4401758, upload-time = "2026-04-18T04:36:11.803Z" },
+    { url = "https://files.pythonhosted.org/packages/40/44/3ee09a5b60cb44c4f2fbc1c9015cfd6ff5afc08f991cab295d3024dcbf2d/lxml-6.1.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:7da13bb6fbadfafb474e0226a30570a3445cfd47c86296f2446dafbd77079ace", size = 3508860, upload-time = "2026-04-18T04:32:48.619Z" },
+]
+
+[[package]]
+name = "manifold3d"
+version = "3.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0e/08/ec95dfe566d314e19940de27c50f7a885df9639989b50314c1f5555b10b3/manifold3d-3.2.1.tar.gz", hash = "sha256:d2e6b90a9a95e1649d29ca85057dee39d60564c25a045a092c0e05f1b1fdd8b4", size = 267591, upload-time = "2025-08-06T06:34:24.275Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/64/d5/84d375e989ca0039530e27ff63b8c2971cc3008d0711f0e3f9570de89bbd/manifold3d-3.2.1-cp310-cp310-macosx_10_14_universal2.whl", hash = "sha256:8f8163bf4aa221fb3d23ca9e2f56431219f598e2ba24df8ea26e12d143cbec71", size = 1591571, upload-time = "2025-08-06T06:33:31.046Z" },
+    { url = "https://files.pythonhosted.org/packages/29/4b/f9e5c29ed6bb87ad1c24be227146dac4f04a6f1215ee01b1c28256e49244/manifold3d-3.2.1-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:0108c083b2758aebce2ac2fc29fb29f46289d558844b21e4744a1d577a97bae5", size = 878827, upload-time = "2025-08-06T06:33:32.938Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/17/1ed9210f11594cde0456cb8b2c2e20bb0c6ab2b6ae9a681a917471dd9197/manifold3d-3.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:44efc6e00222c8c7b85b61c3d034eed1409fd7e62f080c9464318f262332566b", size = 744758, upload-time = "2025-08-06T06:33:34.369Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/f4/3c30fcd041254e2a59a4bdc27128ea9db37abf8ac91526ceca4800058f29/manifold3d-3.2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f82288f99fab708f3e40b423b4192ce8ff089f39e3d2c0cf4fca26fcbd551fb9", size = 1047096, upload-time = "2025-08-06T06:33:36.014Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/d3/fba3d76bcb8b9974977fc2d1272a354393b9c1f4f310d394cf8ec342ccf9/manifold3d-3.2.1-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c15af55290bdb8637fb7140707a8814c387825b66174a1da9488eff6433f36b3", size = 1201000, upload-time = "2025-08-06T06:33:37.514Z" },
+    { url = "https://files.pythonhosted.org/packages/54/55/852d54cfce1bf89f6a3d93df3f073e5c6057781afa2e48dd79910c94ea9b/manifold3d-3.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:5aa6fb650dd70d6963e361f3ed36cf5b2ebe6043205f6a8b339598421f3657ec", size = 938315, upload-time = "2025-08-06T06:33:39.304Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/f7/ac11d5248d7e8a9337f3314b5efc85880ddf3a5be04c149957679d40788e/manifold3d-3.2.1-cp311-cp311-macosx_10_14_universal2.whl", hash = "sha256:b13c7aa3d5501eed2edbd749f6f73583fdec0059cb43cbd5c51408f15fc35ee1", size = 1605010, upload-time = "2025-08-06T06:33:40.984Z" },
+    { url = "https://files.pythonhosted.org/packages/98/25/dd2711127bdf7d55ddf399a2c5d58fadc386f06bfab07878ecfe07e46327/manifold3d-3.2.1-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:8b1365525bc29611f895311d2aa3edc0e310cd597d2459b8a98a03d853467cb6", size = 892135, upload-time = "2025-08-06T06:33:42.701Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/65/85aa44894451d07644ebbb997a7e8173aac48a424c3f93673f4c7ad082f1/manifold3d-3.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:aa1afee319af785d064a524a29521c84dab15e1c6a0302f93fd5865e0eb2e171", size = 757844, upload-time = "2025-08-06T06:33:43.978Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/81/f7e81f632d91da51f258e9c1e3d7fb7abd5c4dd9c276db5542c58710d10e/manifold3d-3.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:86e7eb06b36510c20b820dd87adad3dcf73be8b2452c91a92e082fe585f6631c", size = 1060116, upload-time = "2025-08-06T06:33:45.628Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/2f/e6fe1810ba27c5773b1effc0011b2f665e9549dde644bab813502c307ffb/manifold3d-3.2.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:218fc3abf3654045dc6a413774531cfbe33eef4eb87f2fe2238523042fe170bb", size = 1213786, upload-time = "2025-08-06T06:33:46.984Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/1b/d3569f429542a97b36b8d549ba73b27f014687be742b1790b224b46d408b/manifold3d-3.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:a1bbd3527e5adf8177e1bdf6f4ba6cc5ae88cb513615703226ce058a583affee", size = 951314, upload-time = "2025-08-06T06:33:48.282Z" },
+    { url = "https://files.pythonhosted.org/packages/67/05/a39c0f0073f2843f969f798cc4eca8ddee28bc7f73dee9311252b8250f64/manifold3d-3.2.1-cp312-cp312-macosx_10_14_universal2.whl", hash = "sha256:8c579285f745386b1cdcb9ef643fbf6e848822ffa6b1d626b3229b2b48fa5244", size = 1604749, upload-time = "2025-08-06T06:33:49.769Z" },
+    { url = "https://files.pythonhosted.org/packages/71/cb/67610cac14690f5e1e20fdde9249de76a7e0ff73b5bb1ade1a52ecaeb943/manifold3d-3.2.1-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:4d6f8dad9b9093e64650c6557e35bd2c8d1bf60ca389ceb267ebf6ed981c0364", size = 892589, upload-time = "2025-08-06T06:33:51.199Z" },
+    { url = "https://files.pythonhosted.org/packages/53/1d/8dcdf43aafa596cfd00ec2045667e11ec1583f46ce9e3c8ee42f9b54753f/manifold3d-3.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cabf2a04d10a7496c528fdbd0726afbf9b47d452782b05935e2cf14bd564fe57", size = 757244, upload-time = "2025-08-06T06:33:52.574Z" },
+    { url = "https://files.pythonhosted.org/packages/37/c8/bdf4fa62d96559dd84926b6237d4b157c3b760c43f8f92f13f26ee04cd0f/manifold3d-3.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c96a9697617118d7148e7bac829ab31848dd1f1c776a3cc514da6032dad4e815", size = 1059266, upload-time = "2025-08-06T06:33:53.931Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/24/c63faf4c466e32345597e8a27af1151a957800a8a317dcaf126a8e17aa96/manifold3d-3.2.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:97980907caf39be40a9b3cf1a810abe3f51b134461652dc39d8dc3c7d29e838a", size = 1215227, upload-time = "2025-08-06T06:33:55.283Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/03/999b3af03ca26322f1b74eee669d44e8c81c0b1a07ba45c933fcd54efd38/manifold3d-3.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:47303224614e9faa457137a696b8b5d3490eed5855469eefcb65ff3ebd325680", size = 950602, upload-time = "2025-08-06T06:33:56.735Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/8b/22ab908e018e407302cfe8da1a69dab0227953efe960a57208e4eeecfc53/manifold3d-3.2.1-cp313-cp313-macosx_10_14_universal2.whl", hash = "sha256:aa82bb6036f87c9e18b25b4e34c83f302160cb789ff6006efe7e06826646ae89", size = 1604540, upload-time = "2025-08-06T06:33:58.543Z" },
+    { url = "https://files.pythonhosted.org/packages/60/9a/9e6254c016c1f523e877915da825d623ca913fcdf3cc3fa405a7c4774fa9/manifold3d-3.2.1-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:6e8988244e27ddc5220d3987b9f5fef7ea4649a034bde44f5e4a5b0128b93732", size = 892508, upload-time = "2025-08-06T06:33:59.976Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/4f/354c588bee85718936452a7ea11288888888c600cd927dfd42dff70d76ee/manifold3d-3.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ed7694845adbcc28da8578aad6bbefa14c11850ce5c0ad69fea53655992ca8e3", size = 757157, upload-time = "2025-08-06T06:34:01.297Z" },
+    { url = "https://files.pythonhosted.org/packages/54/73/d57dfd8b0471a96694bfa6a62e4f4a57b424a78947b364b25eef45184ab9/manifold3d-3.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:37c0b21dc22dfaeac35af406ec5a36c3242c4ff7f6d141b77f36c4be0c11b7af", size = 1059069, upload-time = "2025-08-06T06:34:02.728Z" },
+    { url = "https://files.pythonhosted.org/packages/12/bb/67cc08b036711ae8cc8600b2463dd5b4dd80c29d2a8b1ef0c6a8aa370de8/manifold3d-3.2.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7472626f6726697da756e6c8b7cb9bd1bf334427b8572c97d5d2096d7f32759f", size = 1215124, upload-time = "2025-08-06T06:34:04.358Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/df/6ec7f89a5153ee8ff07acbe961bb940f6a8b5f60ca9dafa1ac9f2f051caf/manifold3d-3.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:54ea9f4f26c26259eb865de12ae26de84887547d21352a0d63abeb3778a60112", size = 950467, upload-time = "2025-08-06T06:34:05.952Z" },
+]
+
+[[package]]
+name = "mapbox-earcut"
+version = "1.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8d/70/0a322197c1178f47941e5e6e13b0a4adeaaa7c465c18e3b4ead3eba49860/mapbox_earcut-1.0.3.tar.gz", hash = "sha256:b6bac5d519d9947a6321a699c15d58e0b5740da61b9210ed229e05ad207c1c04", size = 24029, upload-time = "2024-12-25T12:49:09.119Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/0a/da73cb98a03e28ebf806df15b4154e1b1956bd9d2eae17b70a54298db85c/mapbox_earcut-1.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5f999a8651bdb3ae8805c9a7cf91337bbb5e858d7724811f3b5baa79bfa3c61a", size = 69723, upload-time = "2024-12-25T12:47:55.204Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/a1/be2258d38215ecd00febebf808d50d56840c059123ea52b9cc1e655d8eab/mapbox_earcut-1.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a59cc707fc0d47f778f912ede6b21e8798e7d82829d772cf2ebaea216cb04828", size = 64037, upload-time = "2024-12-25T12:47:57.667Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/8c/0573fce0e72335695f2d9c42014b716b700170850323074b4c9026d762b7/mapbox_earcut-1.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:30923be0a1080a4d6815b3a0f9d43e2fcc2b2c3fabd4ce3b1fe858c676e449ff", size = 95478, upload-time = "2024-12-25T12:48:00.14Z" },
+    { url = "https://files.pythonhosted.org/packages/93/ff/08815aac9ac1ef0a0972a3c020238c2218f11e21afc4308981d78b12fd86/mapbox_earcut-1.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d105c10a2b849191b4bc72debbc386595c42a2d65a39dbcda05497475066c1a4", size = 1069535, upload-time = "2024-12-25T12:48:02.848Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/a5/0b8effbe0a4bcb019bc4e1726ce0bf6f77a5e405b424cb0d562396f0dd05/mapbox_earcut-1.0.3-cp310-cp310-win32.whl", hash = "sha256:6906cfc9fe5778c8efcdae425df52a414de5e75cb0ebe31175fbfaa038dec0d9", size = 63950, upload-time = "2024-12-25T12:48:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/af/fe/593275fa703161d0c28388f20f26f02c5c34adf532250506fb2058a59101/mapbox_earcut-1.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:624b99bb7bba37bcf889c84d338516cdbbfaa612a03e6bc48d2ebdfbadddddfc", size = 71246, upload-time = "2024-12-25T12:48:06.681Z" },
+    { url = "https://files.pythonhosted.org/packages/61/d7/b37a45c248100e7285a40de87a8b1808ca4ca10228e265f2d0c320702d96/mapbox_earcut-1.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:bbf24029e7447eb0351000f4fd3185327a00dac5ed756b07330b0bdaed6932db", size = 71057, upload-time = "2024-12-25T12:48:09.131Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/df/2b63eb0d3a24e14f67adc816de18c2e09f3eb0997c512ace84dd59c3ed96/mapbox_earcut-1.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:998e2f1e3769538f7656a34296d08a37cb71ce57aa8cf4387572bc00029b52ce", size = 65300, upload-time = "2024-12-25T12:48:11.677Z" },
+    { url = "https://files.pythonhosted.org/packages/87/37/9dd9575f5c00e35d480e7150e5bb315a35d9cf5642bfb75ca628a31e1341/mapbox_earcut-1.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:df2382d84d6d168f73479673d297753e37440772f233cc03ebb54d150e37b174", size = 96965, upload-time = "2024-12-25T12:48:12.968Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/91/5708233941b5bf73149ba35f7aa32c6ee2cf4a33cd33069e7dba69d4129f/mapbox_earcut-1.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3ccddb4bb04f11beab62943eb5a1bcd52c5a71d236bfce0ecc03e45e97fdb24b", size = 1070953, upload-time = "2024-12-25T12:48:15.495Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/fe/b35b999ba786aa17ddc47bc04231de076665eb511e1cd58cf6fef3581172/mapbox_earcut-1.0.3-cp311-cp311-win32.whl", hash = "sha256:f19b2bcf6475bc591f48437d3214691a6730f39b1f6dfd7505b69c4345485b0c", size = 65245, upload-time = "2024-12-25T12:48:17.826Z" },
+    { url = "https://files.pythonhosted.org/packages/11/81/18ac08b0bb0c22dd9028c7ecb31ae4086d31128b13fb3903e717331072ac/mapbox_earcut-1.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:811a64ad5e6ecf09b96af533e5c169299ba173e53eb4ff0209de1adcfae314be", size = 72356, upload-time = "2024-12-25T12:48:20.164Z" },
+    { url = "https://files.pythonhosted.org/packages/96/7c/707a4ce96e078f7d382cc32b4a6c2326eca68d77ead5e990f5f940d16140/mapbox_earcut-1.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5be71b7ec2180a27ce1178d53933430a3292b6ac3f94f2144513ee51d9034007", size = 70333, upload-time = "2024-12-25T12:48:22.565Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/47/ba2a14732f6e197b0ed879a1992b4d85054294b23627ad681b4fb1251d16/mapbox_earcut-1.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:eb874f7562a49ae0fb7bd47bcc9b4854cc53e3e4f7f26674f02f3cadb006ce16", size = 64697, upload-time = "2024-12-25T12:48:25.025Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/68/59a514811da76c3c801207bd6d7094ea5ba75648c2e7f15d4cb98b08216f/mapbox_earcut-1.0.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:73b9f06f2f8a795d835342aa80e021cfceda78fdca7bc07dc1a0b4aca90239f3", size = 96182, upload-time = "2024-12-25T12:48:26.316Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/79/97bf509ade0f9aeb5b5f94b1aff86393c2f584379a80e392fdfcbea434ae/mapbox_earcut-1.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fdc55574ef7b613004874a459d2d59c07e1ef45cebb83f86c4958f7d3e2d6069", size = 1070584, upload-time = "2024-12-25T12:48:29.065Z" },
+    { url = "https://files.pythonhosted.org/packages/de/7a/5a6e205bab9ff49d1dae392f6179a444f820880d8985f26080816fa6c7ba/mapbox_earcut-1.0.3-cp312-cp312-win32.whl", hash = "sha256:790f52c67a0bd81032eaf61ebc181b1825b8b6daf01cb69e9eaa38521dd07aeb", size = 65375, upload-time = "2024-12-25T12:48:30.618Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/59/674a67f92772563d5a943ce2c4ed834ed341e3a0fd77b8eb4b79057f5193/mapbox_earcut-1.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:cc1bbf35be0d9853dd448374330684ddbd0112497dee7d21b7417b0ab6236ac7", size = 72575, upload-time = "2024-12-25T12:48:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0c/33d1fe1df098d33fce673fe153a52a7ef482bae19afcc295aa36bfdd7d33/mapbox_earcut-1.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:22859490a83a614750dee24c08502fbe14f01a808c0f0f8626261b43ec186762", size = 70373, upload-time = "2024-12-25T12:48:35.399Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/f0/3c7d62f1e0aea0285da578ea1c98686c8d915143df17ff5ed37b04882cac/mapbox_earcut-1.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ad9b97512b7e917cec9af399a344f8844b0ca6c074f354a5b06f58c393c4d9b0", size = 64755, upload-time = "2024-12-25T12:48:37.872Z" },
+    { url = "https://files.pythonhosted.org/packages/13/9a/9eb83efbe87ebf41d1a78efe3c0d906212e5dd91c8f24a9fc7491908ccd5/mapbox_earcut-1.0.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:05de0accc70431c2270dbb13fd75b6f10b19624d42f26b377995b1fb46ac5844", size = 96198, upload-time = "2024-12-25T12:48:39.202Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/4a/24182a96ad4bb086b04fff5d14c9f62fc3b89000bea2f05240aa6128bd03/mapbox_earcut-1.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2d25c856a1ee6c69f51b82df5a06ea6cea66ce3a7c6043a602edfc5c2fe33e32", size = 1070844, upload-time = "2024-12-25T12:48:40.702Z" },
+    { url = "https://files.pythonhosted.org/packages/67/9d/edc1f0bb03079293a28f7d1e5d496ee0da16822908c09268b049aa056288/mapbox_earcut-1.0.3-cp313-cp313-win32.whl", hash = "sha256:9ec67d2dc733c7235114e5fa93baae4aa2de8c6210e01e8efd85e5b9cc0deb53", size = 65431, upload-time = "2024-12-25T12:48:43.249Z" },
+    { url = "https://files.pythonhosted.org/packages/93/f1/e6987c97bb4bac6daf0084e72f457d5214bc8b054d465363060364121a9b/mapbox_earcut-1.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:473012494fd7a51c424a6835fb03c9ee461c540df87492f0ee9bb2f56c456c0c", size = 72586, upload-time = "2024-12-25T12:48:45.629Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/14/8b58520cb6fe393a064e4e681abe7afcb9d7861b4f56be0cf4a72f9143f1/mapbox_earcut-1.0.3-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:17cdd6f14d1161839eea67a0ce796a09bcb3183903dc7b213011f38907b71279", size = 70105, upload-time = "2024-12-25T12:48:55.892Z" },
+    { url = "https://files.pythonhosted.org/packages/35/e3/83b76439cdb8ad790ad4ddefd5025b7509e4a94ec120333d0c387acb4c81/mapbox_earcut-1.0.3-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:ae5aab4b8b3e418c4690da17b3aa50e7fc540b08a0d0d43a4eff4fa21ecb51b3", size = 64231, upload-time = "2024-12-25T12:48:57.124Z" },
+    { url = "https://files.pythonhosted.org/packages/65/af/06ddfda61d8ff4e7c182185e13f2eae65935eb33e185098d1fed67a4f9fa/mapbox_earcut-1.0.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ab51cd69c768c15114da8ba8f43bcda1dea681167e6eadd067fda34837a639d", size = 95920, upload-time = "2024-12-25T12:48:59.227Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/77/edb2f8e0026b5419feb92c7c30a33dc1df0de0790c90e0a1770690725375/mapbox_earcut-1.0.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:97f9bcbcd897db68b02228f20255d56b269248883d1ac51686e3de15a83bec7d", size = 71300, upload-time = "2024-12-25T12:49:00.824Z" },
+]
+
+[[package]]
+name = "markdown"
+version = "3.9"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8d/37/02347f6d6d8279247a5837082ebc26fc0d5aaeaf75aa013fcbb433c777ab/markdown-3.9.tar.gz", hash = "sha256:d2900fe1782bd33bdbbd56859defef70c2e78fc46668f8eb9df3128138f2cb6a", size = 364585, upload-time = "2025-09-04T20:25:22.885Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/70/ae/44c4a6a4cbb496d93c6257954260fe3a6e91b7bed2240e5dad2a717f5111/markdown-3.9-py3-none-any.whl", hash = "sha256:9f4d91ed810864ea88a6f32c07ba8bee1346c0cc1f6b1f9f6c822f2a9667d280", size = 107441, upload-time = "2025-09-04T20:25:21.784Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "3.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596, upload-time = "2023-06-03T06:41:14.443Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload-time = "2023-06-03T06:41:11.019Z" },
+]
+
+[[package]]
+name = "markupsafe"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/4b/3541d44f3937ba468b75da9eebcae497dcf67adb65caa16760b0a6807ebb/markupsafe-3.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559", size = 11631, upload-time = "2025-09-27T18:36:05.558Z" },
+    { url = "https://files.pythonhosted.org/packages/98/1b/fbd8eed11021cabd9226c37342fa6ca4e8a98d8188a8d9b66740494960e4/markupsafe-3.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419", size = 12057, upload-time = "2025-09-27T18:36:07.165Z" },
+    { url = "https://files.pythonhosted.org/packages/40/01/e560d658dc0bb8ab762670ece35281dec7b6c1b33f5fbc09ebb57a185519/markupsafe-3.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695", size = 22050, upload-time = "2025-09-27T18:36:08.005Z" },
+    { url = "https://files.pythonhosted.org/packages/af/cd/ce6e848bbf2c32314c9b237839119c5a564a59725b53157c856e90937b7a/markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591", size = 20681, upload-time = "2025-09-27T18:36:08.881Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/2a/b5c12c809f1c3045c4d580b035a743d12fcde53cf685dbc44660826308da/markupsafe-3.0.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c", size = 20705, upload-time = "2025-09-27T18:36:10.131Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/e3/9427a68c82728d0a88c50f890d0fc072a1484de2f3ac1ad0bfc1a7214fd5/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f", size = 21524, upload-time = "2025-09-27T18:36:11.324Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/36/23578f29e9e582a4d0278e009b38081dbe363c5e7165113fad546918a232/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6", size = 20282, upload-time = "2025-09-27T18:36:12.573Z" },
+    { url = "https://files.pythonhosted.org/packages/56/21/dca11354e756ebd03e036bd8ad58d6d7168c80ce1fe5e75218e4945cbab7/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1", size = 20745, upload-time = "2025-09-27T18:36:13.504Z" },
+    { url = "https://files.pythonhosted.org/packages/87/99/faba9369a7ad6e4d10b6a5fbf71fa2a188fe4a593b15f0963b73859a1bbd/markupsafe-3.0.3-cp310-cp310-win32.whl", hash = "sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa", size = 14571, upload-time = "2025-09-27T18:36:14.779Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/25/55dc3ab959917602c96985cb1253efaa4ff42f71194bddeb61eb7278b8be/markupsafe-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8", size = 15056, upload-time = "2025-09-27T18:36:16.125Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/9e/0a02226640c255d1da0b8d12e24ac2aa6734da68bff14c05dd53b94a0fc3/markupsafe-3.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1", size = 13932, upload-time = "2025-09-27T18:36:17.311Z" },
+    { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" },
+    { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" },
+    { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" },
+    { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" },
+    { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" },
+    { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" },
+    { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" },
+    { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" },
+    { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" },
+    { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" },
+    { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" },
+    { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" },
+    { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" },
+    { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" },
+    { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" },
+]
+
+[[package]]
+name = "matplotlib"
+version = "3.10.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "contourpy", version = "1.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "contourpy", version = "1.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "cycler" },
+    { name = "fonttools" },
+    { name = "kiwisolver" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "packaging" },
+    { name = "pillow" },
+    { name = "pyparsing" },
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8a/76/d3c6e3a13fe484ebe7718d14e269c9569c4eb0020a968a327acb3b9a8fe6/matplotlib-3.10.8.tar.gz", hash = "sha256:2299372c19d56bcd35cf05a2738308758d32b9eaed2371898d8f5bd33f084aa3", size = 34806269, upload-time = "2025-12-10T22:56:51.155Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/58/be/a30bd917018ad220c400169fba298f2bb7003c8ccbc0c3e24ae2aacad1e8/matplotlib-3.10.8-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:00270d217d6b20d14b584c521f810d60c5c78406dc289859776550df837dcda7", size = 8239828, upload-time = "2025-12-10T22:55:02.313Z" },
+    { url = "https://files.pythonhosted.org/packages/58/27/ca01e043c4841078e82cf6e80a6993dfecd315c3d79f5f3153afbb8e1ec6/matplotlib-3.10.8-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:37b3c1cc42aa184b3f738cfa18c1c1d72fd496d85467a6cf7b807936d39aa656", size = 8128050, upload-time = "2025-12-10T22:55:04.997Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/aa/7ab67f2b729ae6a91bcf9dcac0affb95fb8c56f7fd2b2af894ae0b0cf6fa/matplotlib-3.10.8-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ee40c27c795bda6a5292e9cff9890189d32f7e3a0bf04e0e3c9430c4a00c37df", size = 8700452, upload-time = "2025-12-10T22:55:07.47Z" },
+    { url = "https://files.pythonhosted.org/packages/73/ae/2d5817b0acee3c49b7e7ccfbf5b273f284957cc8e270adf36375db353190/matplotlib-3.10.8-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a48f2b74020919552ea25d222d5cc6af9ca3f4eb43a93e14d068457f545c2a17", size = 9534928, upload-time = "2025-12-10T22:55:10.566Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/5b/8e66653e9f7c39cb2e5cab25fce4810daffa2bff02cbf5f3077cea9e942c/matplotlib-3.10.8-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f254d118d14a7f99d616271d6c3c27922c092dac11112670b157798b89bf4933", size = 9586377, upload-time = "2025-12-10T22:55:12.362Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/e2/fd0bbadf837f81edb0d208ba8f8cb552874c3b16e27cb91a31977d90875d/matplotlib-3.10.8-cp310-cp310-win_amd64.whl", hash = "sha256:f9b587c9c7274c1613a30afabf65a272114cd6cdbe67b3406f818c79d7ab2e2a", size = 8128127, upload-time = "2025-12-10T22:55:14.436Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/86/de7e3a1cdcfc941483af70609edc06b83e7c8a0e0dc9ac325200a3f4d220/matplotlib-3.10.8-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:6be43b667360fef5c754dda5d25a32e6307a03c204f3c0fc5468b78fa87b4160", size = 8251215, upload-time = "2025-12-10T22:55:16.175Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/14/baad3222f424b19ce6ad243c71de1ad9ec6b2e4eb1e458a48fdc6d120401/matplotlib-3.10.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a2b336e2d91a3d7006864e0990c83b216fcdca64b5a6484912902cef87313d78", size = 8139625, upload-time = "2025-12-10T22:55:17.712Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/a0/7024215e95d456de5883e6732e708d8187d9753a21d32f8ddb3befc0c445/matplotlib-3.10.8-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:efb30e3baaea72ce5928e32bab719ab4770099079d66726a62b11b1ef7273be4", size = 8712614, upload-time = "2025-12-10T22:55:20.8Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f4/b8347351da9a5b3f41e26cf547252d861f685c6867d179a7c9d60ad50189/matplotlib-3.10.8-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d56a1efd5bfd61486c8bc968fa18734464556f0fb8e51690f4ac25d85cbbbbc2", size = 9540997, upload-time = "2025-12-10T22:55:23.258Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c0/c7b914e297efe0bc36917bf216b2acb91044b91e930e878ae12981e461e5/matplotlib-3.10.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:238b7ce5717600615c895050239ec955d91f321c209dd110db988500558e70d6", size = 9596825, upload-time = "2025-12-10T22:55:25.217Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d3/a4bbc01c237ab710a1f22b4da72f4ff6d77eb4c7735ea9811a94ae239067/matplotlib-3.10.8-cp311-cp311-win_amd64.whl", hash = "sha256:18821ace09c763ec93aef5eeff087ee493a24051936d7b9ebcad9662f66501f9", size = 8135090, upload-time = "2025-12-10T22:55:27.162Z" },
+    { url = "https://files.pythonhosted.org/packages/89/dd/a0b6588f102beab33ca6f5218b31725216577b2a24172f327eaf6417d5c9/matplotlib-3.10.8-cp311-cp311-win_arm64.whl", hash = "sha256:bab485bcf8b1c7d2060b4fcb6fc368a9e6f4cd754c9c2fea281f4be21df394a2", size = 8012377, upload-time = "2025-12-10T22:55:29.185Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/67/f997cdcbb514012eb0d10cd2b4b332667997fb5ebe26b8d41d04962fa0e6/matplotlib-3.10.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:64fcc24778ca0404ce0cb7b6b77ae1f4c7231cdd60e6778f999ee05cbd581b9a", size = 8260453, upload-time = "2025-12-10T22:55:30.709Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/65/07d5f5c7f7c994f12c768708bd2e17a4f01a2b0f44a1c9eccad872433e2e/matplotlib-3.10.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b9a5ca4ac220a0cdd1ba6bcba3608547117d30468fefce49bb26f55c1a3d5c58", size = 8148321, upload-time = "2025-12-10T22:55:33.265Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/f3/c5195b1ae57ef85339fd7285dfb603b22c8b4e79114bae5f4f0fcf688677/matplotlib-3.10.8-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3ab4aabc72de4ff77b3ec33a6d78a68227bf1123465887f9905ba79184a1cc04", size = 8716944, upload-time = "2025-12-10T22:55:34.922Z" },
+    { url = "https://files.pythonhosted.org/packages/00/f9/7638f5cc82ec8a7aa005de48622eecc3ed7c9854b96ba15bd76b7fd27574/matplotlib-3.10.8-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:24d50994d8c5816ddc35411e50a86ab05f575e2530c02752e02538122613371f", size = 9550099, upload-time = "2025-12-10T22:55:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/57/61/78cd5920d35b29fd2a0fe894de8adf672ff52939d2e9b43cb83cd5ce1bc7/matplotlib-3.10.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:99eefd13c0dc3b3c1b4d561c1169e65fe47aab7b8158754d7c084088e2329466", size = 9613040, upload-time = "2025-12-10T22:55:38.715Z" },
+    { url = "https://files.pythonhosted.org/packages/30/4e/c10f171b6e2f44d9e3a2b96efa38b1677439d79c99357600a62cc1e9594e/matplotlib-3.10.8-cp312-cp312-win_amd64.whl", hash = "sha256:dd80ecb295460a5d9d260df63c43f4afbdd832d725a531f008dad1664f458adf", size = 8142717, upload-time = "2025-12-10T22:55:41.103Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/76/934db220026b5fef85f45d51a738b91dea7d70207581063cd9bd8fafcf74/matplotlib-3.10.8-cp312-cp312-win_arm64.whl", hash = "sha256:3c624e43ed56313651bc18a47f838b60d7b8032ed348911c54906b130b20071b", size = 8012751, upload-time = "2025-12-10T22:55:42.684Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/b9/15fd5541ef4f5b9a17eefd379356cf12175fe577424e7b1d80676516031a/matplotlib-3.10.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3f2e409836d7f5ac2f1c013110a4d50b9f7edc26328c108915f9075d7d7a91b6", size = 8261076, upload-time = "2025-12-10T22:55:44.648Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/a0/2ba3473c1b66b9c74dc7107c67e9008cb1782edbe896d4c899d39ae9cf78/matplotlib-3.10.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56271f3dac49a88d7fca5060f004d9d22b865f743a12a23b1e937a0be4818ee1", size = 8148794, upload-time = "2025-12-10T22:55:46.252Z" },
+    { url = "https://files.pythonhosted.org/packages/75/97/a471f1c3eb1fd6f6c24a31a5858f443891d5127e63a7788678d14e249aea/matplotlib-3.10.8-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a0a7f52498f72f13d4a25ea70f35f4cb60642b466cbb0a9be951b5bc3f45a486", size = 8718474, upload-time = "2025-12-10T22:55:47.864Z" },
+    { url = "https://files.pythonhosted.org/packages/01/be/cd478f4b66f48256f42927d0acbcd63a26a893136456cd079c0cc24fbabf/matplotlib-3.10.8-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:646d95230efb9ca614a7a594d4fcacde0ac61d25e37dd51710b36477594963ce", size = 9549637, upload-time = "2025-12-10T22:55:50.048Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7c/8dc289776eae5109e268c4fb92baf870678dc048a25d4ac903683b86d5bf/matplotlib-3.10.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f89c151aab2e2e23cb3fe0acad1e8b82841fd265379c4cecd0f3fcb34c15e0f6", size = 9613678, upload-time = "2025-12-10T22:55:52.21Z" },
+    { url = "https://files.pythonhosted.org/packages/64/40/37612487cc8a437d4dd261b32ca21fe2d79510fe74af74e1f42becb1bdb8/matplotlib-3.10.8-cp313-cp313-win_amd64.whl", hash = "sha256:e8ea3e2d4066083e264e75c829078f9e149fa119d27e19acd503de65e0b13149", size = 8142686, upload-time = "2025-12-10T22:55:54.253Z" },
+    { url = "https://files.pythonhosted.org/packages/66/52/8d8a8730e968185514680c2a6625943f70269509c3dcfc0dcf7d75928cb8/matplotlib-3.10.8-cp313-cp313-win_arm64.whl", hash = "sha256:c108a1d6fa78a50646029cb6d49808ff0fc1330fda87fa6f6250c6b5369b6645", size = 8012917, upload-time = "2025-12-10T22:55:56.268Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/27/51fe26e1062f298af5ef66343d8ef460e090a27fea73036c76c35821df04/matplotlib-3.10.8-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:ad3d9833a64cf48cc4300f2b406c3d0f4f4724a91c0bd5640678a6ba7c102077", size = 8305679, upload-time = "2025-12-10T22:55:57.856Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/1e/4de865bc591ac8e3062e835f42dd7fe7a93168d519557837f0e37513f629/matplotlib-3.10.8-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:eb3823f11823deade26ce3b9f40dcb4a213da7a670013929f31d5f5ed1055b22", size = 8198336, upload-time = "2025-12-10T22:55:59.371Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/cb/2f7b6e75fb4dce87ef91f60cac4f6e34f4c145ab036a22318ec837971300/matplotlib-3.10.8-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d9050fee89a89ed57b4fb2c1bfac9a3d0c57a0d55aed95949eedbc42070fea39", size = 8731653, upload-time = "2025-12-10T22:56:01.032Z" },
+    { url = "https://files.pythonhosted.org/packages/46/b3/bd9c57d6ba670a37ab31fb87ec3e8691b947134b201f881665b28cc039ff/matplotlib-3.10.8-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b44d07310e404ba95f8c25aa5536f154c0a8ec473303535949e52eb71d0a1565", size = 9561356, upload-time = "2025-12-10T22:56:02.95Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/3d/8b94a481456dfc9dfe6e39e93b5ab376e50998cddfd23f4ae3b431708f16/matplotlib-3.10.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:0a33deb84c15ede243aead39f77e990469fff93ad1521163305095b77b72ce4a", size = 9614000, upload-time = "2025-12-10T22:56:05.411Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/cd/bc06149fe5585ba800b189a6a654a75f1f127e8aab02fd2be10df7fa500c/matplotlib-3.10.8-cp313-cp313t-win_amd64.whl", hash = "sha256:3a48a78d2786784cc2413e57397981fb45c79e968d99656706018d6e62e57958", size = 8220043, upload-time = "2025-12-10T22:56:07.551Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/de/b22cf255abec916562cc04eef457c13e58a1990048de0c0c3604d082355e/matplotlib-3.10.8-cp313-cp313t-win_arm64.whl", hash = "sha256:15d30132718972c2c074cd14638c7f4592bd98719e2308bccea40e0538bc0cb5", size = 8062075, upload-time = "2025-12-10T22:56:09.178Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/43/31d59500bb950b0d188e149a2e552040528c13d6e3d6e84d0cccac593dcd/matplotlib-3.10.8-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:f97aeb209c3d2511443f8797e3e5a569aebb040d4f8bc79aa3ee78a8fb9e3dd8", size = 8237252, upload-time = "2025-12-10T22:56:39.529Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/2c/615c09984f3c5f907f51c886538ad785cf72e0e11a3225de2c0f9442aecc/matplotlib-3.10.8-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:fb061f596dad3a0f52b60dc6a5dec4a0c300dec41e058a7efe09256188d170b7", size = 8124693, upload-time = "2025-12-10T22:56:41.758Z" },
+    { url = "https://files.pythonhosted.org/packages/91/e1/2757277a1c56041e1fc104b51a0f7b9a4afc8eb737865d63cababe30bc61/matplotlib-3.10.8-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:12d90df9183093fcd479f4172ac26b322b1248b15729cb57f42f71f24c7e37a3", size = 8702205, upload-time = "2025-12-10T22:56:43.415Z" },
+    { url = "https://files.pythonhosted.org/packages/04/30/3afaa31c757f34b7725ab9d2ba8b48b5e89c2019c003e7d0ead143aabc5a/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:6da7c2ce169267d0d066adcf63758f0604aa6c3eebf67458930f9d9b79ad1db1", size = 8249198, upload-time = "2025-12-10T22:56:45.584Z" },
+    { url = "https://files.pythonhosted.org/packages/48/2f/6334aec331f57485a642a7c8be03cb286f29111ae71c46c38b363230063c/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9153c3292705be9f9c64498a8872118540c3f4123d1a1c840172edf262c8be4a", size = 8136817, upload-time = "2025-12-10T22:56:47.339Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e4/6d6f14b2a759c622f191b2d67e9075a3f56aaccb3be4bb9bb6890030d0a0/matplotlib-3.10.8-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ae029229a57cd1e8fe542485f27e7ca7b23aa9e8944ddb4985d0bc444f1eca2", size = 8713867, upload-time = "2025-12-10T22:56:48.954Z" },
+]
+
+[[package]]
+name = "matplotlib-inline"
+version = "0.1.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/99/5b/a36a337438a14116b16480db471ad061c36c3694df7c2084a0da7ba538b7/matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90", size = 8159, upload-time = "2024-04-15T13:44:44.803Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899, upload-time = "2024-04-15T13:44:43.265Z" },
+]
+
+[[package]]
+name = "mdit-py-plugins"
+version = "0.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b2/fd/a756d36c0bfba5f6e39a1cdbdbfdd448dc02692467d83816dff4592a1ebc/mdit_py_plugins-0.5.0.tar.gz", hash = "sha256:f4918cb50119f50446560513a8e311d574ff6aaed72606ddae6d35716fe809c6", size = 44655, upload-time = "2025-08-11T07:25:49.083Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/86/dd6e5db36df29e76c7a7699123569a4a18c1623ce68d826ed96c62643cae/mdit_py_plugins-0.5.0-py3-none-any.whl", hash = "sha256:07a08422fc1936a5d26d146759e9155ea466e842f5ab2f7d2266dd084c8dab1f", size = 57205, upload-time = "2025-08-11T07:25:47.597Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "mediapy"
+version = "1.2.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ipython", version = "8.37.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "ipython", version = "9.6.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "matplotlib" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "pillow" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7c/99/8b59dbcebf7e84b35e86c893f52fdc2953299d66ef1fcbacca26162818b0/mediapy-1.2.7.tar.gz", hash = "sha256:fd3826ca156f9165cd369f44d4d345d5609df1da3caf867df7ce304e19dd7fde", size = 28660, upload-time = "2026-07-01T13:14:43.448Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/10/70/eeb41d81fea2b3165cfe7ae1c662f9dc6310b14b230a96260376c2891cc7/mediapy-1.2.7-py3-none-any.whl", hash = "sha256:fc81a9190d9724b02286efac4e7a67f384024e078fda0a3cac9fdf25e2f8878f", size = 28015, upload-time = "2026-07-01T13:14:42.524Z" },
+]
+
+[[package]]
+name = "mjlab"
+version = "1.6.0"
+source = { editable = "." }
+dependencies = [
+    { name = "imageio-ffmpeg" },
+    { name = "mediapy" },
+    { name = "mjviser" },
+    { name = "mujoco" },
+    { name = "mujoco-warp" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "onnxscript" },
+    { name = "prettytable" },
+    { name = "rsl-rl-lib" },
+    { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "scipy", version = "1.16.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "tensorboard" },
+    { name = "tensordict" },
+    { name = "torch", version = "2.9.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform == 'darwin' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128')" },
+    { name = "torch", version = "2.9.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "torch", version = "2.10.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "torchrunx" },
+    { name = "tqdm" },
+    { name = "trimesh" },
+    { name = "tyro" },
+    { name = "viser" },
+    { name = "wandb" },
+    { name = "warp-lang", version = "1.14.0", source = { registry = "https://pypi.nvidia.com/" }, marker = "sys_platform != 'darwin' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "warp-lang", version = "1.14.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform == 'darwin' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+
+[package.optional-dependencies]
+cpu = [
+    { name = "torch", version = "2.9.0", source = { registry = "https://pypi.org/simple" }, marker = "(sys_platform == 'darwin' and extra == 'extra-5-mjlab-cpu') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "torch", version = "2.10.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+cu128 = [
+    { name = "torch", version = "2.9.0", source = { registry = "https://pypi.org/simple" }, marker = "(sys_platform == 'darwin' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "torch", version = "2.9.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "ipdb" },
+    { name = "onnxruntime", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "pre-commit" },
+    { name = "pyright" },
+    { name = "pytest" },
+    { name = "ruff" },
+    { name = "ty" },
+]
+docs = [
+    { name = "autodocsumm" },
+    { name = "myst-parser" },
+    { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx-autobuild", version = "2024.10.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx-autobuild", version = "2025.8.25", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx-autodoc-typehints", version = "3.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx-autodoc-typehints", version = "3.5.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx-book-theme" },
+    { name = "sphinx-copybutton" },
+    { name = "sphinx-design" },
+    { name = "sphinx-icon" },
+    { name = "sphinx-multiversion" },
+    { name = "sphinx-tabs" },
+    { name = "sphinxcontrib-bibtex" },
+    { name = "sphinxemoji" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "imageio-ffmpeg" },
+    { name = "mediapy", specifier = ">=1.2.7" },
+    { name = "mjviser", specifier = ">=0.0.14" },
+    { name = "mujoco", specifier = "~=3.11.0" },
+    { name = "mujoco-warp", specifier = "~=3.11.0" },
+    { name = "numpy" },
+    { name = "onnxscript", specifier = ">=0.5.4" },
+    { name = "prettytable" },
+    { name = "rsl-rl-lib", specifier = "==5.5.0" },
+    { name = "scipy", specifier = ">=1.15" },
+    { name = "tensorboard", specifier = ">=2.20.0" },
+    { name = "tensordict" },
+    { name = "torch", specifier = ">=2.7.0" },
+    { name = "torch", marker = "sys_platform == 'darwin' and extra == 'cpu'", specifier = ">=2.7.0" },
+    { name = "torch", marker = "sys_platform == 'darwin' and extra == 'cu128'", specifier = ">=2.7.0" },
+    { name = "torch", marker = "sys_platform != 'darwin' and extra == 'cpu'", specifier = ">=2.7.0", index = "https://download.pytorch.org/whl/cpu", conflict = { package = "mjlab", extra = "cpu" } },
+    { name = "torch", marker = "sys_platform != 'darwin' and extra == 'cu128'", specifier = ">=2.7.0", index = "https://download.pytorch.org/whl/cu128", conflict = { package = "mjlab", extra = "cu128" } },
+    { name = "torchrunx", specifier = ">=0.3.4" },
+    { name = "tqdm" },
+    { name = "trimesh", specifier = ">=4.8.3" },
+    { name = "tyro", specifier = ">=1.0.1" },
+    { name = "viser", specifier = ">=1.0.27" },
+    { name = "wandb", specifier = ">=0.22.3" },
+    { name = "warp-lang", marker = "sys_platform != 'darwin'", specifier = ">=1.14.0", index = "https://pypi.nvidia.com/" },
+    { name = "warp-lang", marker = "sys_platform == 'darwin'", specifier = ">=1.14.0" },
+]
+provides-extras = ["cu128", "cpu"]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "ipdb", specifier = ">=0.13.13" },
+    { name = "onnxruntime", marker = "python_full_version >= '3.11'", specifier = ">=1.19.0" },
+    { name = "pre-commit", specifier = ">=4.3.0" },
+    { name = "pyright", specifier = ">=1.1.408" },
+    { name = "pytest", specifier = ">=9.0.3" },
+    { name = "ruff", specifier = ">=0.16.1" },
+    { name = "ty", specifier = ">=0.0.14" },
+]
+docs = [
+    { name = "autodocsumm" },
+    { name = "myst-parser", specifier = ">=4.0.1" },
+    { name = "sphinx", specifier = ">=8.1.3" },
+    { name = "sphinx-autobuild", specifier = ">=2024.10.3" },
+    { name = "sphinx-autodoc-typehints", specifier = ">=3.0.1" },
+    { name = "sphinx-book-theme", specifier = ">=1.1.4" },
+    { name = "sphinx-copybutton", specifier = ">=0.5.2" },
+    { name = "sphinx-design", specifier = ">=0.6.1" },
+    { name = "sphinx-icon" },
+    { name = "sphinx-multiversion" },
+    { name = "sphinx-tabs" },
+    { name = "sphinxcontrib-bibtex" },
+    { name = "sphinxemoji" },
+]
+
+[[package]]
+name = "mjviser"
+version = "0.0.14"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mujoco" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "pillow" },
+    { name = "trimesh" },
+    { name = "viser" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1d/e4/eef89b279fb1811b5f120a99ac9284c32ff2ca4fad5e6f5c93035f72ba9a/mjviser-0.0.14.tar.gz", hash = "sha256:ebde2203dab89959a13ae549b4d3e5e5cf9eb69de11a1a2fd759cbe8f8c641f3", size = 29576, upload-time = "2026-05-07T03:35:13.128Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9c/c2/4534d678ad1b3f7dee6fd83110112800287be21ba007d988abb9ddc8e0ac/mjviser-0.0.14-py3-none-any.whl", hash = "sha256:4b09f8e90506fc4a71d76fc628872147157947e9292428213ab78cfe137c9a26", size = 32296, upload-time = "2026-05-07T03:35:14.252Z" },
+]
+
+[[package]]
+name = "ml-dtypes"
+version = "0.5.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0e/4a/c27b42ed9b1c7d13d9ba8b6905dece787d6259152f2309338aed29b2447b/ml_dtypes-0.5.4.tar.gz", hash = "sha256:8ab06a50fb9bf9666dd0fe5dfb4676fa2b0ac0f31ecff72a6c3af8e22c063453", size = 692314, upload-time = "2025-11-17T22:32:31.031Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fe/3a/c5b855752a70267ff729c349e650263adb3c206c29d28cc8ea7ace30a1d5/ml_dtypes-0.5.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b95e97e470fe60ed493fd9ae3911d8da4ebac16bd21f87ffa2b7c588bf22ea2c", size = 679735, upload-time = "2025-11-17T22:31:31.367Z" },
+    { url = "https://files.pythonhosted.org/packages/41/79/7433f30ee04bd4faa303844048f55e1eb939131c8e5195a00a96a0939b64/ml_dtypes-0.5.4-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4b801ebe0b477be666696bda493a9be8356f1f0057a57f1e35cd26928823e5a", size = 5051883, upload-time = "2025-11-17T22:31:33.658Z" },
+    { url = "https://files.pythonhosted.org/packages/10/b1/8938e8830b0ee2e167fc75a094dea766a1152bde46752cd9bfc57ee78a82/ml_dtypes-0.5.4-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:388d399a2152dd79a3f0456a952284a99ee5c93d3e2f8dfe25977511e0515270", size = 5030369, upload-time = "2025-11-17T22:31:35.595Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/a3/51886727bd16e2f47587997b802dd56398692ce8c6c03c2e5bb32ecafe26/ml_dtypes-0.5.4-cp310-cp310-win_amd64.whl", hash = "sha256:4ff7f3e7ca2972e7de850e7b8fcbb355304271e2933dd90814c1cb847414d6e2", size = 210738, upload-time = "2025-11-17T22:31:37.43Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/5e/712092cfe7e5eb667b8ad9ca7c54442f21ed7ca8979745f1000e24cf8737/ml_dtypes-0.5.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6c7ecb74c4bd71db68a6bea1edf8da8c34f3d9fe218f038814fd1d310ac76c90", size = 679734, upload-time = "2025-11-17T22:31:39.223Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/cf/912146dfd4b5c0eea956836c01dcd2fce6c9c844b2691f5152aca196ce4f/ml_dtypes-0.5.4-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bc11d7e8c44a65115d05e2ab9989d1e045125d7be8e05a071a48bc76eb6d6040", size = 5056165, upload-time = "2025-11-17T22:31:41.071Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/80/19189ea605017473660e43762dc853d2797984b3c7bf30ce656099add30c/ml_dtypes-0.5.4-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:19b9a53598f21e453ea2fbda8aa783c20faff8e1eeb0d7ab899309a0053f1483", size = 5034975, upload-time = "2025-11-17T22:31:42.758Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/24/70bd59276883fdd91600ca20040b41efd4902a923283c4d6edcb1de128d2/ml_dtypes-0.5.4-cp311-cp311-win_amd64.whl", hash = "sha256:7c23c54a00ae43edf48d44066a7ec31e05fdc2eee0be2b8b50dd1903a1db94bb", size = 210742, upload-time = "2025-11-17T22:31:44.068Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c9/64230ef14e40aa3f1cb254ef623bf812735e6bec7772848d19131111ac0d/ml_dtypes-0.5.4-cp311-cp311-win_arm64.whl", hash = "sha256:557a31a390b7e9439056644cb80ed0735a6e3e3bb09d67fd5687e4b04238d1de", size = 160709, upload-time = "2025-11-17T22:31:46.557Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/b8/3c70881695e056f8a32f8b941126cf78775d9a4d7feba8abcb52cb7b04f2/ml_dtypes-0.5.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a174837a64f5b16cab6f368171a1a03a27936b31699d167684073ff1c4237dac", size = 676927, upload-time = "2025-11-17T22:31:48.182Z" },
+    { url = "https://files.pythonhosted.org/packages/54/0f/428ef6881782e5ebb7eca459689448c0394fa0a80bea3aa9262cba5445ea/ml_dtypes-0.5.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a7f7c643e8b1320fd958bf098aa7ecf70623a42ec5154e3be3be673f4c34d900", size = 5028464, upload-time = "2025-11-17T22:31:50.135Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/cb/28ce52eb94390dda42599c98ea0204d74799e4d8047a0eb559b6fd648056/ml_dtypes-0.5.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ad459e99793fa6e13bd5b7e6792c8f9190b4e5a1b45c63aba14a4d0a7f1d5ff", size = 5009002, upload-time = "2025-11-17T22:31:52.001Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/f0/0cfadd537c5470378b1b32bd859cf2824972174b51b873c9d95cfd7475a5/ml_dtypes-0.5.4-cp312-cp312-win_amd64.whl", hash = "sha256:c1a953995cccb9e25a4ae19e34316671e4e2edaebe4cf538229b1fc7109087b7", size = 212222, upload-time = "2025-11-17T22:31:53.742Z" },
+    { url = "https://files.pythonhosted.org/packages/16/2e/9acc86985bfad8f2c2d30291b27cd2bb4c74cea08695bd540906ed744249/ml_dtypes-0.5.4-cp312-cp312-win_arm64.whl", hash = "sha256:9bad06436568442575beb2d03389aa7456c690a5b05892c471215bfd8cf39460", size = 160793, upload-time = "2025-11-17T22:31:55.358Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/a1/4008f14bbc616cfb1ac5b39ea485f9c63031c4634ab3f4cf72e7541f816a/ml_dtypes-0.5.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8c760d85a2f82e2bed75867079188c9d18dae2ee77c25a54d60e9cc79be1bc48", size = 676888, upload-time = "2025-11-17T22:31:56.907Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/b7/dff378afc2b0d5a7d6cd9d3209b60474d9819d1189d347521e1688a60a53/ml_dtypes-0.5.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ce756d3a10d0c4067172804c9cc276ba9cc0ff47af9078ad439b075d1abdc29b", size = 5036993, upload-time = "2025-11-17T22:31:58.497Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/33/40cd74219417e78b97c47802037cf2d87b91973e18bb968a7da48a96ea44/ml_dtypes-0.5.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:533ce891ba774eabf607172254f2e7260ba5f57bdd64030c9a4fcfbd99815d0d", size = 5010956, upload-time = "2025-11-17T22:31:59.931Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/8b/200088c6859d8221454825959df35b5244fa9bdf263fd0249ac5fb75e281/ml_dtypes-0.5.4-cp313-cp313-win_amd64.whl", hash = "sha256:f21c9219ef48ca5ee78402d5cc831bd58ea27ce89beda894428bc67a52da5328", size = 212224, upload-time = "2025-11-17T22:32:01.349Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/75/dfc3775cb36367816e678f69a7843f6f03bd4e2bcd79941e01ea960a068e/ml_dtypes-0.5.4-cp313-cp313-win_arm64.whl", hash = "sha256:35f29491a3e478407f7047b8a4834e4640a77d2737e0b294d049746507af5175", size = 160798, upload-time = "2025-11-17T22:32:02.864Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/74/e9ddb35fd1dd43b1106c20ced3f53c2e8e7fc7598c15638e9f80677f81d4/ml_dtypes-0.5.4-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:304ad47faa395415b9ccbcc06a0350800bc50eda70f0e45326796e27c62f18b6", size = 702083, upload-time = "2025-11-17T22:32:04.08Z" },
+    { url = "https://files.pythonhosted.org/packages/74/f5/667060b0aed1aa63166b22897fdf16dca9eb704e6b4bbf86848d5a181aa7/ml_dtypes-0.5.4-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6a0df4223b514d799b8a1629c65ddc351b3efa833ccf7f8ea0cf654a61d1e35d", size = 5354111, upload-time = "2025-11-17T22:32:05.546Z" },
+    { url = "https://files.pythonhosted.org/packages/40/49/0f8c498a28c0efa5f5c95a9e374c83ec1385ca41d0e85e7cf40e5d519a21/ml_dtypes-0.5.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531eff30e4d368cb6255bc2328d070e35836aa4f282a0fb5f3a0cd7260257298", size = 5366453, upload-time = "2025-11-17T22:32:07.115Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/27/12607423d0a9c6bbbcc780ad19f1f6baa2b68b18ce4bddcdc122c4c68dc9/ml_dtypes-0.5.4-cp313-cp313t-win_amd64.whl", hash = "sha256:cb73dccfc991691c444acc8c0012bee8f2470da826a92e3a20bb333b1a7894e6", size = 225612, upload-time = "2025-11-17T22:32:08.615Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/80/5a5929e92c72936d5b19872c5fb8fc09327c1da67b3b68c6a13139e77e20/ml_dtypes-0.5.4-cp313-cp313t-win_arm64.whl", hash = "sha256:3bbbe120b915090d9dd1375e4684dd17a20a2491ef25d640a908281da85e73f1", size = 164145, upload-time = "2025-11-17T22:32:09.782Z" },
+]
+
+[[package]]
+name = "mpmath"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" },
+]
+
+[[package]]
+name = "msgspec"
+version = "0.19.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cf/9b/95d8ce458462b8b71b8a70fa94563b2498b89933689f3a7b8911edfae3d7/msgspec-0.19.0.tar.gz", hash = "sha256:604037e7cd475345848116e89c553aa9a233259733ab51986ac924ab1b976f8e", size = 216934, upload-time = "2024-12-27T17:40:28.597Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/13/40/817282b42f58399762267b30deb8ac011d8db373f8da0c212c85fbe62b8f/msgspec-0.19.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d8dd848ee7ca7c8153462557655570156c2be94e79acec3561cf379581343259", size = 190019, upload-time = "2024-12-27T17:39:13.803Z" },
+    { url = "https://files.pythonhosted.org/packages/92/99/bd7ed738c00f223a8119928661167a89124140792af18af513e6519b0d54/msgspec-0.19.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0553bbc77662e5708fe66aa75e7bd3e4b0f209709c48b299afd791d711a93c36", size = 183680, upload-time = "2024-12-27T17:39:17.847Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/27/322badde18eb234e36d4a14122b89edd4e2973cdbc3da61ca7edf40a1ccd/msgspec-0.19.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fe2c4bf29bf4e89790b3117470dea2c20b59932772483082c468b990d45fb947", size = 209334, upload-time = "2024-12-27T17:39:19.065Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/65/080509c5774a1592b2779d902a70b5fe008532759927e011f068145a16cb/msgspec-0.19.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00e87ecfa9795ee5214861eab8326b0e75475c2e68a384002aa135ea2a27d909", size = 211551, upload-time = "2024-12-27T17:39:21.767Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/2e/1c23c6b4ca6f4285c30a39def1054e2bee281389e4b681b5e3711bd5a8c9/msgspec-0.19.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3c4ec642689da44618f68c90855a10edbc6ac3ff7c1d94395446c65a776e712a", size = 215099, upload-time = "2024-12-27T17:39:24.71Z" },
+    { url = "https://files.pythonhosted.org/packages/83/fe/95f9654518879f3359d1e76bc41189113aa9102452170ab7c9a9a4ee52f6/msgspec-0.19.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2719647625320b60e2d8af06b35f5b12d4f4d281db30a15a1df22adb2295f633", size = 218211, upload-time = "2024-12-27T17:39:27.396Z" },
+    { url = "https://files.pythonhosted.org/packages/79/f6/71ca7e87a1fb34dfe5efea8156c9ef59dd55613aeda2ca562f122cd22012/msgspec-0.19.0-cp310-cp310-win_amd64.whl", hash = "sha256:695b832d0091edd86eeb535cd39e45f3919f48d997685f7ac31acb15e0a2ed90", size = 186174, upload-time = "2024-12-27T17:39:29.647Z" },
+    { url = "https://files.pythonhosted.org/packages/24/d4/2ec2567ac30dab072cce3e91fb17803c52f0a37aab6b0c24375d2b20a581/msgspec-0.19.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:aa77046904db764b0462036bc63ef71f02b75b8f72e9c9dd4c447d6da1ed8f8e", size = 187939, upload-time = "2024-12-27T17:39:32.347Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/c0/18226e4328897f4f19875cb62bb9259fe47e901eade9d9376ab5f251a929/msgspec-0.19.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:047cfa8675eb3bad68722cfe95c60e7afabf84d1bd8938979dd2b92e9e4a9551", size = 182202, upload-time = "2024-12-27T17:39:33.633Z" },
+    { url = "https://files.pythonhosted.org/packages/81/25/3a4b24d468203d8af90d1d351b77ea3cffb96b29492855cf83078f16bfe4/msgspec-0.19.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e78f46ff39a427e10b4a61614a2777ad69559cc8d603a7c05681f5a595ea98f7", size = 209029, upload-time = "2024-12-27T17:39:35.023Z" },
+    { url = "https://files.pythonhosted.org/packages/85/2e/db7e189b57901955239f7689b5dcd6ae9458637a9c66747326726c650523/msgspec-0.19.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c7adf191e4bd3be0e9231c3b6dc20cf1199ada2af523885efc2ed218eafd011", size = 210682, upload-time = "2024-12-27T17:39:36.384Z" },
+    { url = "https://files.pythonhosted.org/packages/03/97/7c8895c9074a97052d7e4a1cc1230b7b6e2ca2486714eb12c3f08bb9d284/msgspec-0.19.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f04cad4385e20be7c7176bb8ae3dca54a08e9756cfc97bcdb4f18560c3042063", size = 214003, upload-time = "2024-12-27T17:39:39.097Z" },
+    { url = "https://files.pythonhosted.org/packages/61/61/e892997bcaa289559b4d5869f066a8021b79f4bf8e955f831b095f47a4cd/msgspec-0.19.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:45c8fb410670b3b7eb884d44a75589377c341ec1392b778311acdbfa55187716", size = 216833, upload-time = "2024-12-27T17:39:41.203Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/3d/71b2dffd3a1c743ffe13296ff701ee503feaebc3f04d0e75613b6563c374/msgspec-0.19.0-cp311-cp311-win_amd64.whl", hash = "sha256:70eaef4934b87193a27d802534dc466778ad8d536e296ae2f9334e182ac27b6c", size = 186184, upload-time = "2024-12-27T17:39:43.702Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/5f/a70c24f075e3e7af2fae5414c7048b0e11389685b7f717bb55ba282a34a7/msgspec-0.19.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f98bd8962ad549c27d63845b50af3f53ec468b6318400c9f1adfe8b092d7b62f", size = 190485, upload-time = "2024-12-27T17:39:44.974Z" },
+    { url = "https://files.pythonhosted.org/packages/89/b0/1b9763938cfae12acf14b682fcf05c92855974d921a5a985ecc197d1c672/msgspec-0.19.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:43bbb237feab761b815ed9df43b266114203f53596f9b6e6f00ebd79d178cdf2", size = 183910, upload-time = "2024-12-27T17:39:46.401Z" },
+    { url = "https://files.pythonhosted.org/packages/87/81/0c8c93f0b92c97e326b279795f9c5b956c5a97af28ca0fbb9fd86c83737a/msgspec-0.19.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4cfc033c02c3e0aec52b71710d7f84cb3ca5eb407ab2ad23d75631153fdb1f12", size = 210633, upload-time = "2024-12-27T17:39:49.099Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/ef/c5422ce8af73928d194a6606f8ae36e93a52fd5e8df5abd366903a5ca8da/msgspec-0.19.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d911c442571605e17658ca2b416fd8579c5050ac9adc5e00c2cb3126c97f73bc", size = 213594, upload-time = "2024-12-27T17:39:51.204Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2b/4137bc2ed45660444842d042be2cf5b18aa06efd2cda107cff18253b9653/msgspec-0.19.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:757b501fa57e24896cf40a831442b19a864f56d253679f34f260dcb002524a6c", size = 214053, upload-time = "2024-12-27T17:39:52.866Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/e6/8ad51bdc806aac1dc501e8fe43f759f9ed7284043d722b53323ea421c360/msgspec-0.19.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5f0f65f29b45e2816d8bded36e6b837a4bf5fb60ec4bc3c625fa2c6da4124537", size = 219081, upload-time = "2024-12-27T17:39:55.142Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/ef/27dd35a7049c9a4f4211c6cd6a8c9db0a50647546f003a5867827ec45391/msgspec-0.19.0-cp312-cp312-win_amd64.whl", hash = "sha256:067f0de1c33cfa0b6a8206562efdf6be5985b988b53dd244a8e06f993f27c8c0", size = 187467, upload-time = "2024-12-27T17:39:56.531Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/cb/2842c312bbe618d8fefc8b9cedce37f773cdc8fa453306546dba2c21fd98/msgspec-0.19.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f12d30dd6266557aaaf0aa0f9580a9a8fbeadfa83699c487713e355ec5f0bd86", size = 190498, upload-time = "2024-12-27T17:40:00.427Z" },
+    { url = "https://files.pythonhosted.org/packages/58/95/c40b01b93465e1a5f3b6c7d91b10fb574818163740cc3acbe722d1e0e7e4/msgspec-0.19.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:82b2c42c1b9ebc89e822e7e13bbe9d17ede0c23c187469fdd9505afd5a481314", size = 183950, upload-time = "2024-12-27T17:40:04.219Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/f0/5b764e066ce9aba4b70d1db8b087ea66098c7c27d59b9dd8a3532774d48f/msgspec-0.19.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19746b50be214a54239aab822964f2ac81e38b0055cca94808359d779338c10e", size = 210647, upload-time = "2024-12-27T17:40:05.606Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/87/bc14f49bc95c4cb0dd0a8c56028a67c014ee7e6818ccdce74a4862af259b/msgspec-0.19.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:60ef4bdb0ec8e4ad62e5a1f95230c08efb1f64f32e6e8dd2ced685bcc73858b5", size = 213563, upload-time = "2024-12-27T17:40:10.516Z" },
+    { url = "https://files.pythonhosted.org/packages/53/2f/2b1c2b056894fbaa975f68f81e3014bb447516a8b010f1bed3fb0e016ed7/msgspec-0.19.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac7f7c377c122b649f7545810c6cd1b47586e3aa3059126ce3516ac7ccc6a6a9", size = 213996, upload-time = "2024-12-27T17:40:12.244Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/5a/4cd408d90d1417e8d2ce6a22b98a6853c1b4d7cb7669153e4424d60087f6/msgspec-0.19.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a5bc1472223a643f5ffb5bf46ccdede7f9795078194f14edd69e3aab7020d327", size = 219087, upload-time = "2024-12-27T17:40:14.881Z" },
+    { url = "https://files.pythonhosted.org/packages/23/d8/f15b40611c2d5753d1abb0ca0da0c75348daf1252220e5dda2867bd81062/msgspec-0.19.0-cp313-cp313-win_amd64.whl", hash = "sha256:317050bc0f7739cb30d257ff09152ca309bf5a369854bbf1e57dffc310c1f20f", size = 187432, upload-time = "2024-12-27T17:40:16.256Z" },
+]
+
+[[package]]
+name = "mujoco"
+version = "3.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "absl-py" },
+    { name = "etils", extra = ["epath"] },
+    { name = "glfw" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "pyopengl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3b/2d/290f3f4062eec1c0d5246de0a75f1b18b59a1961081f49ddc97333fc8263/mujoco-3.11.0.tar.gz", hash = "sha256:390856102af9547dfd87cb2791eb105a3d2e00a37323fe9a12ed17e512aff1a6", size = 1139880, upload-time = "2026-07-28T01:23:32.252Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ab/4f/cac3ffdff6fbd63860d1be28a7f45fa1206ed638d4c774fe4505b9563c7c/mujoco-3.11.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6d830dab9f43781980d1e673f06938d80261f9960d8086d8a221ba0118b68c79", size = 17455595, upload-time = "2026-07-28T01:22:20.595Z" },
+    { url = "https://files.pythonhosted.org/packages/be/f5/f8dfdbc9964b24bb1c2fb60467474d7a85f160c609ce29099d6eda9806ec/mujoco-3.11.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aac0102660762fad316cea63b81765593c97bdda0e22251eb64ff561f78e6853", size = 17632593, upload-time = "2026-07-28T01:22:23.616Z" },
+    { url = "https://files.pythonhosted.org/packages/64/f5/9bb09c44bbc7b3d844aed8517f130cbc99e565b5f5e8a55c8f06f40b8129/mujoco-3.11.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:39b813755f4b09b75a0ccaec0e1e37d313bc7c9ca1be94203a9aae3b7829cae0", size = 18727136, upload-time = "2026-07-28T01:22:26.625Z" },
+    { url = "https://files.pythonhosted.org/packages/43/40/e5123f0502dbb61158fa8f73b6d5576d3a818e3b3b07794732760759acf8/mujoco-3.11.0-cp310-cp310-win_amd64.whl", hash = "sha256:c82557572b279dd61540f2da6d61afed64ef765c210e24abeee4f2b2a57660bb", size = 15651634, upload-time = "2026-07-28T01:22:29.765Z" },
+    { url = "https://files.pythonhosted.org/packages/82/cb/eaa909bfdb093d82b80518182db89936fd0cc5486aeac31e71d9940e4800/mujoco-3.11.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:87a70b79d461b3afe03d1cd3dfb44b9ba1955a80b011a87c9536a6ef9c7936c8", size = 17474359, upload-time = "2026-07-28T01:22:32.578Z" },
+    { url = "https://files.pythonhosted.org/packages/68/d6/74fcb2a95b21de5217f19d9eb87db923d337e204da4dedaffeacababd28a/mujoco-3.11.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d09bcec0d9338fd79095314c4bd3a3072d7063e94a27d47f78e6159ca9a2baa9", size = 17655486, upload-time = "2026-07-28T01:22:35.33Z" },
+    { url = "https://files.pythonhosted.org/packages/43/3d/3c933a7a8e7f00e12260ad175195b8bbc36fd3aa62068f00db36351a2147/mujoco-3.11.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:16f94f05745225aaafb68016cbd2a1617f4af6b4bfca6c97d22c7b14e598d1f1", size = 18751041, upload-time = "2026-07-28T01:22:38.149Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/eb/e09d6ac38f3e7af2fec0b3501515973f8a400d9c3d1e22e727a21762f598/mujoco-3.11.0-cp311-cp311-win_amd64.whl", hash = "sha256:5a286601c6a73a21f576ac6405e842a3221eb7db53013084a5c2e341a35112ee", size = 15687351, upload-time = "2026-07-28T01:22:40.864Z" },
+    { url = "https://files.pythonhosted.org/packages/87/b3/b2b449b5978bcb13277c9e50d764e6d8cd9534f58f071fb1647724123e2c/mujoco-3.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3609c198de090c8218b9cc62ca6133f0feede8edd103b743b8002f3f735fcd9b", size = 17511145, upload-time = "2026-07-28T01:22:43.668Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/65/d8130bb8a673f9cdc8a8fb2ef02f9b6931708567de57f17395106e83b4e3/mujoco-3.11.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:517bff03623c3329a563f575afd7d731b0be5c4f92a54dcec934b99120b4a9ec", size = 17704436, upload-time = "2026-07-28T01:22:47.05Z" },
+    { url = "https://files.pythonhosted.org/packages/41/d6/7b79f5d8fbd019658a3b5feb6ffd09c1e727eaf93f518685d3cc105a28f5/mujoco-3.11.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f40214fefc8c2fe0002a3c8abadf30de7a3330634f3c45cc29b407b40a0173fc", size = 18868030, upload-time = "2026-07-28T01:22:50.494Z" },
+    { url = "https://files.pythonhosted.org/packages/19/46/f994cd7d973c4db4f6b5af19ba6eb62703b9aafc8f894c5bc5ceadd31b0d/mujoco-3.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:98c08a5eec9411ecd6f763f1e635fbc8f31e3ea3701584d6b7edcc24d8d6c575", size = 15791637, upload-time = "2026-07-28T01:22:53.922Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/16/4b822d608cb4bc5aafe910b6f6947c73ecd467470935408e4ad0d207023e/mujoco-3.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dd282aae46dc7350472bd4a81dd789ea011ff961c00fd60c9434e67bfd0519a3", size = 17511474, upload-time = "2026-07-28T01:22:57.111Z" },
+    { url = "https://files.pythonhosted.org/packages/47/73/4cbe741986ed86f13e86ad92a11de870bdec4979eaafcbc7ef3164680260/mujoco-3.11.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b1ea2ed1d20b7cca55fc1e0257f2d4f6ab6e83855f669530fb3f55c85da80aac", size = 17704381, upload-time = "2026-07-28T01:23:00.158Z" },
+    { url = "https://files.pythonhosted.org/packages/90/2e/843071e21831fa5ef4029de6874789f9fd32f340d42fced383757c484bdd/mujoco-3.11.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3379c36b508474127b08e51e77942c493c2f1d7215b425e3b95de08dcba662e0", size = 18868301, upload-time = "2026-07-28T01:23:03.054Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/25/2a518a33b359b0798a9e8b55f30a4c9ab0cadd0cab8d85872ff9da6ca309/mujoco-3.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:d48b4a18d409ce4c746f32b3b402a8419b7450d9a89de68b81d73a3ef333d0e4", size = 15792231, upload-time = "2026-07-28T01:23:05.798Z" },
+]
+
+[[package]]
+name = "mujoco-warp"
+version = "3.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "absl-py" },
+    { name = "etils", extra = ["epath"] },
+    { name = "mujoco" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "warp-lang", version = "1.14.0", source = { registry = "https://pypi.nvidia.com/" }, marker = "sys_platform != 'darwin' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "warp-lang", version = "1.14.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform == 'darwin' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2c/02/da883029b3661619651d0e2469ec17df92dd64ca5de25119886d516ee1de/mujoco_warp-3.11.0.tar.gz", hash = "sha256:e9e521a3809b95baa98c44bd4fcaccb035b5c700e2616efc52ebc33d29ae2eef", size = 2075418, upload-time = "2026-07-28T01:21:41.987Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/03/9bf86946c755a9a020c1bea587841472b0206351f73f67e41050fcb2a20c/mujoco_warp-3.11.0-py3-none-any.whl", hash = "sha256:97e77e877c1c2ea064ae68eaace2333dec94f2d8984091ba7b383bc8c34958f6", size = 2153348, upload-time = "2026-07-28T01:21:40.18Z" },
+]
+
+[[package]]
+name = "myst-parser"
+version = "4.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "docutils" },
+    { name = "jinja2" },
+    { name = "markdown-it-py" },
+    { name = "mdit-py-plugins" },
+    { name = "pyyaml" },
+    { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/a5/9626ba4f73555b3735ad86247a8077d4603aa8628537687c839ab08bfe44/myst_parser-4.0.1.tar.gz", hash = "sha256:5cfea715e4f3574138aecbf7d54132296bfd72bb614d31168f48c477a830a7c4", size = 93985, upload-time = "2025-02-12T10:53:03.833Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/df/76d0321c3797b54b60fef9ec3bd6f4cfd124b9e422182156a1dd418722cf/myst_parser-4.0.1-py3-none-any.whl", hash = "sha256:9134e88959ec3b5780aedf8a99680ea242869d012e8821db3126d427edc9c95d", size = 84579, upload-time = "2025-02-12T10:53:02.078Z" },
+]
+
+[[package]]
+name = "networkx"
+version = "3.4.2"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fd/1d/06475e1cd5264c0b870ea2cc6fdb3e37177c1e565c43f56ff17a10e3937f/networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1", size = 2151368, upload-time = "2024-10-21T12:39:38.695Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b9/54/dd730b32ea14ea797530a4479b2ed46a6fb250f682a9cfb997e968bf0261/networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f", size = 1723263, upload-time = "2024-10-21T12:39:36.247Z" },
+]
+
+[[package]]
+name = "networkx"
+version = "3.5"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6c/4f/ccdb8ad3a38e583f214547fd2f7ff1fc160c43a75af88e6aec213404b96a/networkx-3.5.tar.gz", hash = "sha256:d4c6f9cf81f52d69230866796b82afbccdec3db7ae4fbd1b65ea750feed50037", size = 2471065, upload-time = "2025-05-29T11:35:07.804Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/eb/8d/776adee7bbf76365fdd7f2552710282c79a4ead5d2a46408c9043a2b70ba/networkx-3.5-py3-none-any.whl", hash = "sha256:0030d386a9a06dee3565298b4a734b68589749a544acbb6c412dc9e2489ec6ec", size = 2034406, upload-time = "2025-05-29T11:35:04.961Z" },
+]
+
+[[package]]
+name = "nodeenv"
+version = "1.9.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/16/fc88b08840de0e0a72a2f9d8c6bae36be573e475a6326ae854bcc549fc45/nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f", size = 47437, upload-time = "2024-06-04T18:44:11.171Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314, upload-time = "2024-06-04T18:44:08.352Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.2.6"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440, upload-time = "2025-05-17T22:38:04.611Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245, upload-time = "2025-05-17T21:27:58.555Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048, upload-time = "2025-05-17T21:28:21.406Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542, upload-time = "2025-05-17T21:28:30.931Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301, upload-time = "2025-05-17T21:28:41.613Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320, upload-time = "2025-05-17T21:29:02.78Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050, upload-time = "2025-05-17T21:29:27.675Z" },
+    { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034, upload-time = "2025-05-17T21:29:51.102Z" },
+    { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185, upload-time = "2025-05-17T21:30:18.703Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149, upload-time = "2025-05-17T21:30:29.788Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620, upload-time = "2025-05-17T21:30:48.994Z" },
+    { url = "https://files.pythonhosted.org/packages/da/a8/4f83e2aa666a9fbf56d6118faaaf5f1974d456b1823fda0a176eff722839/numpy-2.2.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae", size = 21176963, upload-time = "2025-05-17T21:31:19.36Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/2b/64e1affc7972decb74c9e29e5649fac940514910960ba25cd9af4488b66c/numpy-2.2.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a", size = 14406743, upload-time = "2025-05-17T21:31:41.087Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/9f/0121e375000b5e50ffdd8b25bf78d8e1a5aa4cca3f185d41265198c7b834/numpy-2.2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42", size = 5352616, upload-time = "2025-05-17T21:31:50.072Z" },
+    { url = "https://files.pythonhosted.org/packages/31/0d/b48c405c91693635fbe2dcd7bc84a33a602add5f63286e024d3b6741411c/numpy-2.2.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491", size = 6889579, upload-time = "2025-05-17T21:32:01.712Z" },
+    { url = "https://files.pythonhosted.org/packages/52/b8/7f0554d49b565d0171eab6e99001846882000883998e7b7d9f0d98b1f934/numpy-2.2.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a", size = 14312005, upload-time = "2025-05-17T21:32:23.332Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/dd/2238b898e51bd6d389b7389ffb20d7f4c10066d80351187ec8e303a5a475/numpy-2.2.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf", size = 16821570, upload-time = "2025-05-17T21:32:47.991Z" },
+    { url = "https://files.pythonhosted.org/packages/83/6c/44d0325722cf644f191042bf47eedad61c1e6df2432ed65cbe28509d404e/numpy-2.2.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1", size = 15818548, upload-time = "2025-05-17T21:33:11.728Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/9d/81e8216030ce66be25279098789b665d49ff19eef08bfa8cb96d4957f422/numpy-2.2.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab", size = 18620521, upload-time = "2025-05-17T21:33:39.139Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/fd/e19617b9530b031db51b0926eed5345ce8ddc669bb3bc0044b23e275ebe8/numpy-2.2.6-cp311-cp311-win32.whl", hash = "sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47", size = 6525866, upload-time = "2025-05-17T21:33:50.273Z" },
+    { url = "https://files.pythonhosted.org/packages/31/0a/f354fb7176b81747d870f7991dc763e157a934c717b67b58456bc63da3df/numpy-2.2.6-cp311-cp311-win_amd64.whl", hash = "sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303", size = 12907455, upload-time = "2025-05-17T21:34:09.135Z" },
+    { url = "https://files.pythonhosted.org/packages/82/5d/c00588b6cf18e1da539b45d3598d3557084990dcc4331960c15ee776ee41/numpy-2.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff", size = 20875348, upload-time = "2025-05-17T21:34:39.648Z" },
+    { url = "https://files.pythonhosted.org/packages/66/ee/560deadcdde6c2f90200450d5938f63a34b37e27ebff162810f716f6a230/numpy-2.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c", size = 14119362, upload-time = "2025-05-17T21:35:01.241Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/65/4baa99f1c53b30adf0acd9a5519078871ddde8d2339dc5a7fde80d9d87da/numpy-2.2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3", size = 5084103, upload-time = "2025-05-17T21:35:10.622Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/89/e5a34c071a0570cc40c9a54eb472d113eea6d002e9ae12bb3a8407fb912e/numpy-2.2.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282", size = 6625382, upload-time = "2025-05-17T21:35:21.414Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462, upload-time = "2025-05-17T21:35:42.174Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618, upload-time = "2025-05-17T21:36:06.711Z" },
+    { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511, upload-time = "2025-05-17T21:36:29.965Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783, upload-time = "2025-05-17T21:36:56.883Z" },
+    { url = "https://files.pythonhosted.org/packages/57/0a/72d5a3527c5ebffcd47bde9162c39fae1f90138c961e5296491ce778e682/numpy-2.2.6-cp312-cp312-win32.whl", hash = "sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4", size = 6246506, upload-time = "2025-05-17T21:37:07.368Z" },
+    { url = "https://files.pythonhosted.org/packages/36/fa/8c9210162ca1b88529ab76b41ba02d433fd54fecaf6feb70ef9f124683f1/numpy-2.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2", size = 12614190, upload-time = "2025-05-17T21:37:26.213Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/5c/6657823f4f594f72b5471f1db1ab12e26e890bb2e41897522d134d2a3e81/numpy-2.2.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84", size = 20867828, upload-time = "2025-05-17T21:37:56.699Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/9e/14520dc3dadf3c803473bd07e9b2bd1b69bc583cb2497b47000fed2fa92f/numpy-2.2.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b", size = 14143006, upload-time = "2025-05-17T21:38:18.291Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/06/7e96c57d90bebdce9918412087fc22ca9851cceaf5567a45c1f404480e9e/numpy-2.2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d", size = 5076765, upload-time = "2025-05-17T21:38:27.319Z" },
+    { url = "https://files.pythonhosted.org/packages/73/ed/63d920c23b4289fdac96ddbdd6132e9427790977d5457cd132f18e76eae0/numpy-2.2.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566", size = 6617736, upload-time = "2025-05-17T21:38:38.141Z" },
+    { url = "https://files.pythonhosted.org/packages/85/c5/e19c8f99d83fd377ec8c7e0cf627a8049746da54afc24ef0a0cb73d5dfb5/numpy-2.2.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f", size = 14010719, upload-time = "2025-05-17T21:38:58.433Z" },
+    { url = "https://files.pythonhosted.org/packages/19/49/4df9123aafa7b539317bf6d342cb6d227e49f7a35b99c287a6109b13dd93/numpy-2.2.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f", size = 16526072, upload-time = "2025-05-17T21:39:22.638Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/6c/04b5f47f4f32f7c2b0e7260442a8cbcf8168b0e1a41ff1495da42f42a14f/numpy-2.2.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868", size = 15503213, upload-time = "2025-05-17T21:39:45.865Z" },
+    { url = "https://files.pythonhosted.org/packages/17/0a/5cd92e352c1307640d5b6fec1b2ffb06cd0dabe7d7b8227f97933d378422/numpy-2.2.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d", size = 18316632, upload-time = "2025-05-17T21:40:13.331Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/3b/5cba2b1d88760ef86596ad0f3d484b1cbff7c115ae2429678465057c5155/numpy-2.2.6-cp313-cp313-win32.whl", hash = "sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd", size = 6244532, upload-time = "2025-05-17T21:43:46.099Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/3b/d58c12eafcb298d4e6d0d40216866ab15f59e55d148a5658bb3132311fcf/numpy-2.2.6-cp313-cp313-win_amd64.whl", hash = "sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c", size = 12610885, upload-time = "2025-05-17T21:44:05.145Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/9e/4bf918b818e516322db999ac25d00c75788ddfd2d2ade4fa66f1f38097e1/numpy-2.2.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6", size = 20963467, upload-time = "2025-05-17T21:40:44Z" },
+    { url = "https://files.pythonhosted.org/packages/61/66/d2de6b291507517ff2e438e13ff7b1e2cdbdb7cb40b3ed475377aece69f9/numpy-2.2.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda", size = 14225144, upload-time = "2025-05-17T21:41:05.695Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/25/480387655407ead912e28ba3a820bc69af9adf13bcbe40b299d454ec011f/numpy-2.2.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40", size = 5200217, upload-time = "2025-05-17T21:41:15.903Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4a/6e313b5108f53dcbf3aca0c0f3e9c92f4c10ce57a0a721851f9785872895/numpy-2.2.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8", size = 6712014, upload-time = "2025-05-17T21:41:27.321Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/30/172c2d5c4be71fdf476e9de553443cf8e25feddbe185e0bd88b096915bcc/numpy-2.2.6-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f", size = 14077935, upload-time = "2025-05-17T21:41:49.738Z" },
+    { url = "https://files.pythonhosted.org/packages/12/fb/9e743f8d4e4d3c710902cf87af3512082ae3d43b945d5d16563f26ec251d/numpy-2.2.6-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa", size = 16600122, upload-time = "2025-05-17T21:42:14.046Z" },
+    { url = "https://files.pythonhosted.org/packages/12/75/ee20da0e58d3a66f204f38916757e01e33a9737d0b22373b3eb5a27358f9/numpy-2.2.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571", size = 15586143, upload-time = "2025-05-17T21:42:37.464Z" },
+    { url = "https://files.pythonhosted.org/packages/76/95/bef5b37f29fc5e739947e9ce5179ad402875633308504a52d188302319c8/numpy-2.2.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1", size = 18385260, upload-time = "2025-05-17T21:43:05.189Z" },
+    { url = "https://files.pythonhosted.org/packages/09/04/f2f83279d287407cf36a7a8053a5abe7be3622a4363337338f2585e4afda/numpy-2.2.6-cp313-cp313t-win32.whl", hash = "sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff", size = 6377225, upload-time = "2025-05-17T21:43:16.254Z" },
+    { url = "https://files.pythonhosted.org/packages/67/0e/35082d13c09c02c011cf21570543d202ad929d961c02a147493cb0c2bdf5/numpy-2.2.6-cp313-cp313t-win_amd64.whl", hash = "sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06", size = 12771374, upload-time = "2025-05-17T21:43:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391, upload-time = "2025-05-17T21:44:35.948Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754, upload-time = "2025-05-17T21:44:47.446Z" },
+    { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476, upload-time = "2025-05-17T21:45:11.871Z" },
+    { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666, upload-time = "2025-05-17T21:45:31.426Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.4.6"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz", hash = "sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda", size = 20735807, upload-time = "2026-05-18T23:37:14.07Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/49/ec46835a70be8fa6446c495126ac84fdb28cb2558e1620ffb87a10c8b64c/numpy-2.4.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4", size = 16969194, upload-time = "2026-05-18T23:33:13.503Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/0d/f5957185c0ee2f3e12f78715aa9e3b353fd83633316c8532b38faa37e3f6/numpy-2.4.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d", size = 14964111, upload-time = "2026-05-18T23:33:17.795Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/40/40a40ee0ddf7ceb782c49af278894b686e586d65d8c1889c8b5da01a3d7d/numpy-2.4.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8", size = 5469159, upload-time = "2026-05-18T23:33:20.654Z" },
+    { url = "https://files.pythonhosted.org/packages/63/13/f9a8046535cb21deae82f8d03de9617e08882d274fad2539630761888228/numpy-2.4.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538", size = 6798936, upload-time = "2026-05-18T23:33:22.987Z" },
+    { url = "https://files.pythonhosted.org/packages/33/a8/6fa8c1a345a8c85dbb21932c447bee07c30a2c2a3f31e369c0a84b300147/numpy-2.4.6-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ab0a9c4ffb1a6d95ef519fe4247dba8eb6b18ad93999f76b7f657039acabd47", size = 15966692, upload-time = "2026-05-18T23:33:26.62Z" },
+    { url = "https://files.pythonhosted.org/packages/02/03/74fe2a4cb3817d94d86402f2506554130a2f01414e299b5a843e5a8a957f/numpy-2.4.6-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93", size = 16918164, upload-time = "2026-05-18T23:33:29.955Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/80/3615be3313f7e7696609bc194b9f0101da809df79e859bdb84e0cd043f46/numpy-2.4.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c2d37ab77531417474168eb79d6d80b14f821a966818505d03013d0833edb7a8", size = 17322877, upload-time = "2026-05-18T23:33:34.724Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/ac/a691e0fe2675e370d0e08ff905adc49a1c8830e8cae03efe4477e92cd55d/numpy-2.4.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f407cb6b8e9d6d8c626bc73c945db1706035af8fd632295547bf1c9e46d092d6", size = 18651487, upload-time = "2026-05-18T23:33:38.217Z" },
+    { url = "https://files.pythonhosted.org/packages/15/a7/9bc1cd626d7bf6869bfedf27b91b6ab5dd607758bf8e959d6fa80c6a59cb/numpy-2.4.6-cp311-cp311-win32.whl", hash = "sha256:ddea102b48f9e339f3948bf22040944184627a30fdf7f858667673b9c5f033c8", size = 6233945, upload-time = "2026-05-18T23:33:41.331Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/31/7fc6239c12bce7e931463251cca4426c465e1876ba3cc785402ef4dd8f4e/numpy-2.4.6-cp311-cp311-win_amd64.whl", hash = "sha256:1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147", size = 12608406, upload-time = "2026-05-18T23:33:44.131Z" },
+    { url = "https://files.pythonhosted.org/packages/27/83/140f85a466595a16382996a1bf06b2b54bcd597488921b0c9daaeeda72af/numpy-2.4.6-cp311-cp311-win_arm64.whl", hash = "sha256:ed9749eef4cbd126da3dc1d6bcb3a57f5eb7ac6a6484146bdbf743f552dfc577", size = 10479528, upload-time = "2026-05-18T23:33:50.725Z" },
+    { url = "https://files.pythonhosted.org/packages/95/2a/3d7b5ac8aac24feaf9ad7ed58f45b0bbc06d37e4338ae84c9f2298b570f9/numpy-2.4.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1", size = 16689119, upload-time = "2026-05-18T23:33:54.065Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/12/92c4c131527599e8288d6918e888d88726f84d805d784b771f32408aeaef/numpy-2.4.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb", size = 14699246, upload-time = "2026-05-18T23:33:57.621Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/fe/c0a6b7b2ca128a8fb228575147073b660656734b8ebe4d76c8fd748dcc79/numpy-2.4.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41", size = 5204410, upload-time = "2026-05-18T23:34:00.302Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/d4/9770d14ba719432bb90a421bfd443872ed0f70f7264b64bec12ea363d5fd/numpy-2.4.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698", size = 6551240, upload-time = "2026-05-18T23:34:02.852Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/c6/50a46a6205feba2343f1d6d17438107c5dc491ed1c736e6ea68689fd906b/numpy-2.4.6-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f", size = 15671012, upload-time = "2026-05-18T23:34:05.485Z" },
+    { url = "https://files.pythonhosted.org/packages/99/60/14115e6364fa676c5397c2ad3004e527e9aa487abf5d0706ec81bbd08529/numpy-2.4.6-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853", size = 16645538, upload-time = "2026-05-18T23:34:09.265Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/c5/693cbe59e57db94d2231fa519ca3978dc9e19da5a8f088588f5c6e947ff2/numpy-2.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a", size = 17020706, upload-time = "2026-05-18T23:34:13.053Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/fc/85b7c4eff9b4966ade25c2273cf7e7012e92366c032058653934b37de044/numpy-2.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2", size = 18368541, upload-time = "2026-05-18T23:34:17.024Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/81/e1b27545deedce7f4a0b348618c6b62d74e36a4dc9ccd42f3eb2f85eee32/numpy-2.4.6-cp312-cp312-win32.whl", hash = "sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45", size = 5962825, upload-time = "2026-05-18T23:34:20.3Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/ca/feab00bd44aa5fe1ad2c18f08b4d3bb92e26484b0b1d1443897809ed528c/numpy-2.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751", size = 12321687, upload-time = "2026-05-18T23:34:23.095Z" },
+    { url = "https://files.pythonhosted.org/packages/63/cf/5a6d34850a39d1093558564f77ee8e8e0bee5061151b8f05a55711001ec7/numpy-2.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8", size = 10221482, upload-time = "2026-05-18T23:34:25.876Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/82/bdab26d7438c6791ca31b7c024ca37c1eab8b726ba236129005cd4a06e45/numpy-2.4.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0", size = 16684648, upload-time = "2026-05-18T23:34:29.41Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/30/a80189bcc7f5e4258b3fbc3968d909d1756f54d023299ecc39ad6fdb9ef8/numpy-2.4.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb", size = 14693902, upload-time = "2026-05-18T23:34:33.013Z" },
+    { url = "https://files.pythonhosted.org/packages/97/12/70b5d0d7c15e1ebb8a6a84a8caa1d19e181d84fb58bb6d70aca29099dec1/numpy-2.4.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f", size = 5198992, upload-time = "2026-05-18T23:34:36.132Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/8c/ebd2a8f8a83541f8d38cc5667e8c2b69cecfd30da6e45693e8158857d44b/numpy-2.4.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3", size = 6546944, upload-time = "2026-05-18T23:34:38.484Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/c5/7b863a97a91671a0338f4253bd3b5a3d3852f0692dae91711c9f4a10e787/numpy-2.4.6-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b", size = 15669392, upload-time = "2026-05-18T23:34:41.257Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/9d/3584b9984ca4c047aea75214ce1a4c4c73d849bd71b604264b7f5653f8a8/numpy-2.4.6-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089", size = 16633220, upload-time = "2026-05-18T23:34:45.075Z" },
+    { url = "https://files.pythonhosted.org/packages/05/ae/7c67fba23bd98caec7c99261f3a16072ade14813486b0282cb29846de832/numpy-2.4.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a", size = 17020800, upload-time = "2026-05-18T23:34:49.065Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/5d/3b6725cb31d983c5e66916f5d36f6d7e5521129e4c4404d64f918292a5b6/numpy-2.4.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605", size = 18357600, upload-time = "2026-05-18T23:34:52.709Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/da/2ccc6c2fe8898dee01d90c75c5f5f914a23daf99e3e0f59516a08760c8b5/numpy-2.4.6-cp313-cp313-win32.whl", hash = "sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91", size = 5961134, upload-time = "2026-05-18T23:34:55.618Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/cd/9cc4dc876fb065d5c220aae4d5e14826b2715331bb7618ce1fb07a679d99/numpy-2.4.6-cp313-cp313-win_amd64.whl", hash = "sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359", size = 12318598, upload-time = "2026-05-18T23:34:58.928Z" },
+    { url = "https://files.pythonhosted.org/packages/39/1e/c0bcba1f8694116485fe28fd1be698c278fcda4141c5b0e53a2aed8b12a8/numpy-2.4.6-cp313-cp313-win_arm64.whl", hash = "sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778", size = 10222272, upload-time = "2026-05-18T23:35:02.167Z" },
+    { url = "https://files.pythonhosted.org/packages/63/6d/cc5619247c8f4204e507f5883528372e4ac4bb189e579fb859a12e480b1f/numpy-2.4.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1", size = 14821197, upload-time = "2026-05-18T23:35:05.468Z" },
+    { url = "https://files.pythonhosted.org/packages/00/58/f1c39161c87d9e9bed660f1ed4bafc0e403d5ec9650b6dd77aead07d489b/numpy-2.4.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe", size = 5326287, upload-time = "2026-05-18T23:35:08.693Z" },
+    { url = "https://files.pythonhosted.org/packages/af/57/3917ab0fd97f271a8694513581b8a36c655f111c446852c302f04ccdb6fc/numpy-2.4.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997", size = 6646763, upload-time = "2026-05-18T23:35:11.459Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/0f/037e64c494b67581ae18193d770adef354c41f3f2c8ebf865602d949bf8f/numpy-2.4.6-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20", size = 15728070, upload-time = "2026-05-18T23:35:14.79Z" },
+    { url = "https://files.pythonhosted.org/packages/21/a6/5d2bae9c9542eb4df16dc9c46dc79c186e9bad53805dfa5399a6023c6db0/numpy-2.4.6-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d", size = 16681752, upload-time = "2026-05-18T23:35:18.836Z" },
+    { url = "https://files.pythonhosted.org/packages/92/14/23d1dfb410ae362cd59ce53e936b1513d545eb40db3949ced632e19a459e/numpy-2.4.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67", size = 17086024, upload-time = "2026-05-18T23:35:22.52Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/6e/23595a2c642cdf3bc567877064bdd7f91c8b0038a4453cf2daf7248eafe9/numpy-2.4.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd", size = 18403398, upload-time = "2026-05-18T23:35:26.398Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/90/0ac3bc947217e66dec77e7cbc6a1979d1af70b6461b82f620d3bccd5e4c8/numpy-2.4.6-cp313-cp313t-win32.whl", hash = "sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab", size = 6084971, upload-time = "2026-05-18T23:35:29.387Z" },
+    { url = "https://files.pythonhosted.org/packages/77/71/5673e351671a1d2bd6063b91b44f70c0affea7d1516fa7a6572941ba4aa1/numpy-2.4.6-cp313-cp313t-win_amd64.whl", hash = "sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75", size = 12458532, upload-time = "2026-05-18T23:35:32.175Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/88/19d3503c5046e688f049274b27a3ef3d771152fa80d3ba3d01a3dff61abe/numpy-2.4.6-cp313-cp313t-win_arm64.whl", hash = "sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd", size = 10291881, upload-time = "2026-05-18T23:35:35.465Z" },
+    { url = "https://files.pythonhosted.org/packages/de/12/b422cc84439adc0d00de605bf4a308890ae5c26f2c71fbd73e5d08fbb0dd/numpy-2.4.6-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:55cced7c52e981362f708ad635198e97a752dfba412cc03c23bbf3bd8d5cd662", size = 16847511, upload-time = "2026-05-18T23:36:50.673Z" },
+    { url = "https://files.pythonhosted.org/packages/44/53/f481bef68011740f8849418d82db07230e825013f31f4eef5ba5b805316a/numpy-2.4.6-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d6da64deb6b8ed903e7560180a92f2d804ee1ba5eeb849ac2748b8c1aba1f6d7", size = 14889064, upload-time = "2026-05-18T23:36:53.879Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/57/42ed575c10ced8af951d426bc4e1f8aff16fd851db33f067036215a7f860/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:68a5124b13fa6cc2086764a20005d30bc0548146f7f5322f02fce212ca14317f", size = 5394157, upload-time = "2026-05-18T23:36:57.194Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/ef/f66cc724fcc36c1e364c67f51ae9146090b8b584f27d58b97fdae3edd737/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:948424b06129ce883307e8cff868c31396d8dc7630a59c61d70d98dbe70f222c", size = 6708728, upload-time = "2026-05-18T23:36:59.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/9c/c531f2293b91265d8b48e9b329f54fdd7ffae73cb4134ea10cca4237e9cc/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbbdb29840ca3d91ee0fece42fc29278886d908280bfec0a5846c6f901a3eb0", size = 15798374, upload-time = "2026-05-18T23:37:02.674Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/b0/413077f6b1153ed3cba361401c6783bbad6114804a000cc22eb71c13e190/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ad03c0965fb3c692200e74d458ca28c1dbb4ce96f9a479a8aa041ad5fabca02", size = 16747286, upload-time = "2026-05-18T23:37:06.327Z" },
+    { url = "https://files.pythonhosted.org/packages/15/ce/e5ec180bc41812edcd8daeb8639d205622c0e8c02259d8ab25a0201b3c2a/numpy-2.4.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73", size = 12504263, upload-time = "2026-05-18T23:37:09.715Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.5.1"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/22/fd/89965aa4ac08c74998539fcbf24fa3540f3e15237fbeb6bcf9c908f4aade/numpy-2.5.1.tar.gz", hash = "sha256:a48a113e6afea91f5608793bafa7ef2ad481fefbda87ec5069f483de61cb9fa3", size = 20755553, upload-time = "2026-07-04T17:08:00.933Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/7b/14687aa674250e5e546f616f486b0d56d3631cd5b2415739141ce40bdcea/numpy-2.5.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2c889b56fe48b1018f764b0eec8df59ab654e9148aa91faa12596043500de277", size = 16801574, upload-time = "2026-07-04T17:06:12.423Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/19/cc5bb2a3f2913d27d6dbb2c78d25921fabaedc6741d4a5a615a11f3c5bf3/numpy-2.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ab451b59c5643c570974c43aef780703ef1d3b4965d2be07afd530615a9358d1", size = 11772250, upload-time = "2026-07-04T17:06:15.726Z" },
+    { url = "https://files.pythonhosted.org/packages/42/77/fdf34a71dd30f54979b18603bee915e0aaf825b07afe79acd60b04b691e2/numpy-2.5.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:78798bd5b9ad744056af8efa90e3b9ddaa53272a0848a483084a1cc0a13b2dc0", size = 5331516, upload-time = "2026-07-04T17:06:17.913Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/e2/eb7efa015b4cce41e2517bf182a7fce0d7d5b9d9ed76a29bfa0f4fe4505c/numpy-2.5.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:2ae0ca40bcb22d6ba59c1dfd5446f49940b0f2d821fde133f10dda11f816b84e", size = 6664863, upload-time = "2026-07-04T17:06:20.02Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/4b/a2b32dd94ee9ffbeecb28152240042a3949db33b1c834d44090b80e1b3b8/numpy-2.5.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61ac47e772e6b8ea489e1d2f441a34c5c3ac17327e7ce294cbdf535795ad4e75", size = 15167977, upload-time = "2026-07-04T17:06:21.621Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/a9/6e73d68500f80773f65f0654ea932019d6694329a0eb0ed0533de38df376/numpy-2.5.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:59fda5e192b570217ec2580c96f00e9a7e12ef6866a900eb089b62c1a32545ca", size = 16672469, upload-time = "2026-07-04T17:06:24.064Z" },
+    { url = "https://files.pythonhosted.org/packages/24/7d/ad3e59015135f5261c95fd4cafeff159c955febd83a99a1d9250c4233815/numpy-2.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f7119ebff1a9829e9f431a4f9d28e703023bb6b9fe7c8f724467dbfc27c94ab3", size = 16527531, upload-time = "2026-07-04T17:06:26.69Z" },
+    { url = "https://files.pythonhosted.org/packages/83/d0/a39b2fbcde9cb17a1dac678f254b33a6336298af9df338824c685425d5e8/numpy-2.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e824c2acf8862052246be5a44c15da1777940c60d010dd2aab897824d9c430f9", size = 18431940, upload-time = "2026-07-04T17:06:29.521Z" },
+    { url = "https://files.pythonhosted.org/packages/04/12/cff070947791c1ed425ff76413189adbdc2fbe215eba7ce7fa454a03c7f8/numpy-2.5.1-cp312-cp312-win32.whl", hash = "sha256:08d60c810432eb83360958dea0999ac4cfb94531ea8efcbf0b7f277c2068aeb2", size = 6066764, upload-time = "2026-07-04T17:06:32.571Z" },
+    { url = "https://files.pythonhosted.org/packages/65/66/53f31807a48a750f9d748da273bc3fcedd12b27ff1f3e373bfec55ef2dc0/numpy-2.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:f7d60026c0bdb1380e83bfa7a0419c4577ee4b9a08880afcb6dadeb74c649fa2", size = 12430966, upload-time = "2026-07-04T17:06:34.926Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/2a/d1a88066b1c14186f5d3c0d18c94f17b064511982bab0578d49ee9d43c29/numpy-2.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:17a25e09640602e10bc8de0e6fa2b3fd68eedd84ba6d7842dc8f32f9ab87bd0b", size = 10350488, upload-time = "2026-07-04T17:06:37.785Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/07/ec2a3f0c91761581d4b7104a740791800025983f9a4dc4e73f91a99aeac4/numpy-2.5.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0bfebd8695f9863592fe744be833a258120b14a9f39da255e8aa8fade2c0ddd1", size = 16796419, upload-time = "2026-07-04T17:06:40.37Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/ab/ddb499fc4f8780354395face5b65c7fd107bcd6e1d667a5f07d046956f6f/numpy-2.5.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:30b44a6b53a7ae63c54c089a8726e5563ed302716c5b7ccc85afade40b0e7ff6", size = 11765832, upload-time = "2026-07-04T17:06:42.768Z" },
+    { url = "https://files.pythonhosted.org/packages/88/b3/3c28c558a09fc72100c646dac6d2fce8e834c471b0edca01a29996706117/numpy-2.5.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:6165343f81b56ef8f514f396989e529b61d9dc709b99421b07e9f3e698e2287d", size = 5325143, upload-time = "2026-07-04T17:06:45.466Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/0e/ce19b985bb15c596f4f05954e76cccc77c845083b3b8f938a6c68e523128/numpy-2.5.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4939237038ada79308dda3204ac6462df056b5672b2e25db1149cf873668b3e1", size = 6659749, upload-time = "2026-07-04T17:06:47.288Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/20/1ee6614d64332a1bba6411f38e68cb79eec1b2459e20a623777c5c5492a2/numpy-2.5.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c6759f538fb912fc46de0a6b1758ccf7b57bc7c7ebebc23974fdac3de8db0cd", size = 15164716, upload-time = "2026-07-04T17:06:49.494Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/a7/2bcd3fdbb87804755c35b729bf8709d62025c5f4cfd7d5b2415997097515/numpy-2.5.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9726558e8db4a5bf7929a70ae50f63abda4daf0efe810e3bfbab95976f75fc1a", size = 16661440, upload-time = "2026-07-04T17:06:52.061Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/d7/a41e3310c886fe457d36e670bbf24fae411aca8a7b6ad92a32afd924077c/numpy-2.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3935f3b419b244a02732676fa5317a9193cc596a4c0646db07e5b421229ac9f7", size = 16526305, upload-time = "2026-07-04T17:06:54.605Z" },
+    { url = "https://files.pythonhosted.org/packages/53/75/4333a9a707c1edd3a4e1a0c58eca52c0f31e55089fa80db02b5565b24df7/numpy-2.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dc932a65ded7ce9013d120845a2514dcccb1a67bfc8deb8d37633762951904a6", size = 18423008, upload-time = "2026-07-04T17:06:57.54Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/90/e314a32b1c11a2ffe818ddad3a57b50b4b6e1b6c487192eb50cdef0415d0/numpy-2.5.1-cp313-cp313-win32.whl", hash = "sha256:4b4ff1608417eb7a59da7b967bbb798cacfe071d2caf526a24281cd562072ed9", size = 6063885, upload-time = "2026-07-04T17:07:00.14Z" },
+    { url = "https://files.pythonhosted.org/packages/10/70/800b3fca480af32df9e8ea9f3d4a0c8feb4b32d7f195d174eabbda4829ad/numpy-2.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:6c3fe51bc6a16453d452997053454f309e8e0ed7b42d6b361ce4ac8c32913d74", size = 12425674, upload-time = "2026-07-04T17:07:02.387Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/0b/196350c122f50f6ca56846f2d71efd5e0d24b7b2e07355e019b2e2c7a11e/numpy-2.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:f7feb014281029e628ba2d5a007407443b06e418b6fe451d1e2adcbc8eba0107", size = 10350256, upload-time = "2026-07-04T17:07:04.878Z" },
+]
+
+[[package]]
+name = "nvidia-cublas-cu12"
+version = "12.8.4.1"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/29/99/db44d685f0e257ff0e213ade1964fc459b4a690a73293220e98feb3307cf/nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:b86f6dd8935884615a0683b663891d43781b819ac4f2ba2b0c9604676af346d0", size = 590537124, upload-time = "2025-03-07T01:43:53.556Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/61/e24b560ab2e2eaeb3c839129175fb330dfcfc29e5203196e5541a4c44682/nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:8ac4e771d5a348c551b2a426eda6193c19aa630236b418086020df5ba9667142", size = 594346921, upload-time = "2025-03-07T01:44:31.254Z" },
+    { url = "https://files.pythonhosted.org/packages/70/61/7d7b3c70186fb651d0fbd35b01dbfc8e755f69fd58f817f3d0f642df20c3/nvidia_cublas_cu12-12.8.4.1-py3-none-win_amd64.whl", hash = "sha256:47e9b82132fa8d2b4944e708049229601448aaad7e6f296f630f2d1a32de35af", size = 567544208, upload-time = "2025-03-07T01:53:30.535Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-cupti-cu12"
+version = "12.8.90"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d5/1f/b3bd73445e5cb342727fd24fe1f7b748f690b460acadc27ea22f904502c8/nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4412396548808ddfed3f17a467b104ba7751e6b58678a4b840675c56d21cf7ed", size = 9533318, upload-time = "2025-03-07T01:40:10.421Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/02/2adcaa145158bf1a8295d83591d22e4103dbfd821bcaf6f3f53151ca4ffa/nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ea0cb07ebda26bb9b29ba82cda34849e73c166c18162d3913575b0c9db9a6182", size = 10248621, upload-time = "2025-03-07T01:40:21.213Z" },
+    { url = "https://files.pythonhosted.org/packages/41/bc/83f5426095d93694ae39fe1311431b5d5a9bb82e48bf0dd8e19be2765942/nvidia_cuda_cupti_cu12-12.8.90-py3-none-win_amd64.whl", hash = "sha256:bb479dcdf7e6d4f8b0b01b115260399bf34154a1a2e9fe11c85c517d87efd98e", size = 7015759, upload-time = "2025-03-07T01:51:11.355Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-nvrtc-cu12"
+version = "12.8.93"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/05/6b/32f747947df2da6994e999492ab306a903659555dddc0fbdeb9d71f75e52/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:a7756528852ef889772a84c6cd89d41dfa74667e24cca16bb31f8f061e3e9994", size = 88040029, upload-time = "2025-03-07T01:42:13.562Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/d1/e50d0acaab360482034b84b6e27ee83c6738f7d32182b987f9c7a4e32962/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fc1fec1e1637854b4c0a65fb9a8346b51dd9ee69e61ebaccc82058441f15bce8", size = 43106076, upload-time = "2025-03-07T01:41:59.817Z" },
+    { url = "https://files.pythonhosted.org/packages/45/51/52a3d84baa2136cc8df15500ad731d74d3a1114d4c123e043cb608d4a32b/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-win_amd64.whl", hash = "sha256:7a4b6b2904850fe78e0bd179c4b655c404d4bb799ef03ddc60804247099ae909", size = 73586838, upload-time = "2025-03-07T01:52:13.483Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-runtime-cu12"
+version = "12.8.90"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7c/75/f865a3b236e4647605ea34cc450900854ba123834a5f1598e160b9530c3a/nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:52bf7bbee900262ffefe5e9d5a2a69a30d97e2bc5bb6cc866688caa976966e3d", size = 965265, upload-time = "2025-03-07T01:39:43.533Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/9b/a997b638fcd068ad6e4d53b8551a7d30fe8b404d6f1804abf1df69838932/nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:adade8dcbd0edf427b7204d480d6066d33902cab2a4707dcfc48a2d0fd44ab90", size = 954765, upload-time = "2025-03-07T01:40:01.615Z" },
+    { url = "https://files.pythonhosted.org/packages/30/a5/a515b7600ad361ea14bfa13fb4d6687abf500adc270f19e89849c0590492/nvidia_cuda_runtime_cu12-12.8.90-py3-none-win_amd64.whl", hash = "sha256:c0c6027f01505bfed6c3b21ec546f69c687689aad5f1a377554bc6ca4aa993a8", size = 944318, upload-time = "2025-03-07T01:51:01.794Z" },
+]
+
+[[package]]
+name = "nvidia-cudnn-cu12"
+version = "9.10.2.21"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-cublas-cu12", marker = "(platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu') or (platform_machine == 's390x' and sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (platform_machine != 's390x' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform != 'linux' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/41/e79269ce215c857c935fd86bcfe91a451a584dfc27f1e068f568b9ad1ab7/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:c9132cc3f8958447b4910a1720036d9eff5928cc3179b0a51fb6d167c6cc87d8", size = 705026878, upload-time = "2025-06-06T21:52:51.348Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/51/e123d997aa098c61d029f76663dedbfb9bc8dcf8c60cbd6adbe42f76d049/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:949452be657fa16687d0930933f032835951ef0892b37d2d53824d1a84dc97a8", size = 706758467, upload-time = "2025-06-06T21:54:08.597Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/90/0bd6e586701b3a890fd38aa71c387dab4883d619d6e5ad912ccbd05bfd67/nvidia_cudnn_cu12-9.10.2.21-py3-none-win_amd64.whl", hash = "sha256:c6288de7d63e6cf62988f0923f96dc339cea362decb1bf5b3141883392a7d65e", size = 692992268, upload-time = "2025-06-06T21:55:18.114Z" },
+]
+
+[[package]]
+name = "nvidia-cufft-cu12"
+version = "11.3.3.83"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu') or (platform_machine == 's390x' and sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (platform_machine != 's390x' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform != 'linux' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/60/bc/7771846d3a0272026c416fbb7e5f4c1f146d6d80704534d0b187dd6f4800/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:848ef7224d6305cdb2a4df928759dca7b1201874787083b6e7550dd6765ce69a", size = 193109211, upload-time = "2025-03-07T01:44:56.873Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/13/ee4e00f30e676b66ae65b4f08cb5bcbb8392c03f54f2d5413ea99a5d1c80/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d2dd21ec0b88cf61b62e6b43564355e5222e4a3fb394cac0db101f2dd0d4f74", size = 193118695, upload-time = "2025-03-07T01:45:27.821Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/ec/ce1629f1e478bb5ccd208986b5f9e0316a78538dd6ab1d0484f012f8e2a1/nvidia_cufft_cu12-11.3.3.83-py3-none-win_amd64.whl", hash = "sha256:7a64a98ef2a7c47f905aaf8931b69a3a43f27c55530c698bb2ed7c75c0b42cb7", size = 192216559, upload-time = "2025-03-07T01:53:57.106Z" },
+]
+
+[[package]]
+name = "nvidia-cufile-cu12"
+version = "1.13.1.3"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bb/fe/1bcba1dfbfb8d01be8d93f07bfc502c93fa23afa6fd5ab3fc7c1df71038a/nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1d069003be650e131b21c932ec3d8969c1715379251f8d23a1860554b1cb24fc", size = 1197834, upload-time = "2025-03-07T01:45:50.723Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/f5/5607710447a6fe9fd9b3283956fceeee8a06cda1d2f56ce31371f595db2a/nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:4beb6d4cce47c1a0f1013d72e02b0994730359e17801d395bdcbf20cfb3bb00a", size = 1120705, upload-time = "2025-03-07T01:45:41.434Z" },
+]
+
+[[package]]
+name = "nvidia-curand-cu12"
+version = "10.3.9.90"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/45/5e/92aa15eca622a388b80fbf8375d4760738df6285b1e92c43d37390a33a9a/nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:dfab99248034673b779bc6decafdc3404a8a6f502462201f2f31f11354204acd", size = 63625754, upload-time = "2025-03-07T01:46:10.735Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/aa/6584b56dc84ebe9cf93226a5cde4d99080c8e90ab40f0c27bda7a0f29aa1/nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:b32331d4f4df5d6eefa0554c565b626c7216f87a06a4f56fab27c3b68a830ec9", size = 63619976, upload-time = "2025-03-07T01:46:23.323Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/75/70c05b2f3ed5be3bb30b7102b6eb78e100da4bbf6944fd6725c012831cab/nvidia_curand_cu12-10.3.9.90-py3-none-win_amd64.whl", hash = "sha256:f149a8ca457277da854f89cf282d6ef43176861926c7ac85b2a0fbd237c587ec", size = 62765309, upload-time = "2025-03-07T01:54:20.478Z" },
+]
+
+[[package]]
+name = "nvidia-cusolver-cu12"
+version = "11.7.3.90"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-cublas-cu12", marker = "(platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu') or (platform_machine == 's390x' and sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (platform_machine != 's390x' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform != 'linux' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cusparse-cu12", marker = "(platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu') or (platform_machine == 's390x' and sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (platform_machine != 's390x' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform != 'linux' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu') or (platform_machine == 's390x' and sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (platform_machine != 's390x' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform != 'linux' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c8/32/f7cd6ce8a7690544d084ea21c26e910a97e077c9b7f07bf5de623ee19981/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:db9ed69dbef9715071232caa9b69c52ac7de3a95773c2db65bdba85916e4e5c0", size = 267229841, upload-time = "2025-03-07T01:46:54.356Z" },
+    { url = "https://files.pythonhosted.org/packages/85/48/9a13d2975803e8cf2777d5ed57b87a0b6ca2cc795f9a4f59796a910bfb80/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:4376c11ad263152bd50ea295c05370360776f8c3427b30991df774f9fb26c450", size = 267506905, upload-time = "2025-03-07T01:47:16.273Z" },
+    { url = "https://files.pythonhosted.org/packages/13/c0/76ca8551b8a84146ffa189fec81c26d04adba4bc0dbe09cd6e6fd9b7de04/nvidia_cusolver_cu12-11.7.3.90-py3-none-win_amd64.whl", hash = "sha256:4a550db115fcabc4d495eb7d39ac8b58d4ab5d8e63274d3754df1c0ad6a22d34", size = 256720438, upload-time = "2025-03-07T01:54:39.898Z" },
+]
+
+[[package]]
+name = "nvidia-cusparse-cu12"
+version = "12.5.8.93"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu') or (platform_machine == 's390x' and sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (platform_machine != 's390x' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform != 'linux' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bc/f7/cd777c4109681367721b00a106f491e0d0d15cfa1fd59672ce580ce42a97/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:9b6c161cb130be1a07a27ea6923df8141f3c295852f4b260c65f18f3e0a091dc", size = 288117129, upload-time = "2025-03-07T01:47:40.407Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/f5/e1854cb2f2bcd4280c44736c93550cc300ff4b8c95ebe370d0aa7d2b473d/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ec05d76bbbd8b61b06a80e1eaf8cf4959c3d4ce8e711b65ebd0443bb0ebb13b", size = 288216466, upload-time = "2025-03-07T01:48:13.779Z" },
+    { url = "https://files.pythonhosted.org/packages/62/07/f3b2ad63f8e3d257a599f422ae34eb565e70c41031aecefa3d18b62cabd1/nvidia_cusparse_cu12-12.5.8.93-py3-none-win_amd64.whl", hash = "sha256:9a33604331cb2cac199f2e7f5104dfbb8a5a898c367a53dfda9ff2acb6b6b4dd", size = 284937404, upload-time = "2025-03-07T01:55:07.742Z" },
+]
+
+[[package]]
+name = "nvidia-cusparselt-cu12"
+version = "0.7.1"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/73/b9/598f6ff36faaece4b3c50d26f50e38661499ff34346f00e057760b35cc9d/nvidia_cusparselt_cu12-0.7.1-py3-none-manylinux2014_aarch64.whl", hash = "sha256:8878dce784d0fac90131b6817b607e803c36e629ba34dc5b433471382196b6a5", size = 283835557, upload-time = "2025-02-26T00:16:54.265Z" },
+    { url = "https://files.pythonhosted.org/packages/56/79/12978b96bd44274fe38b5dde5cfb660b1d114f70a65ef962bcbbed99b549/nvidia_cusparselt_cu12-0.7.1-py3-none-manylinux2014_x86_64.whl", hash = "sha256:f1bb701d6b930d5a7cea44c19ceb973311500847f81b634d802b7b539dc55623", size = 287193691, upload-time = "2025-02-26T00:15:44.104Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/d8/a6b0d0d0c2435e9310f3e2bb0d9c9dd4c33daef86aa5f30b3681defd37ea/nvidia_cusparselt_cu12-0.7.1-py3-none-win_amd64.whl", hash = "sha256:f67fbb5831940ec829c9117b7f33807db9f9678dc2a617fbe781cac17b4e1075", size = 271020911, upload-time = "2025-02-26T00:14:47.204Z" },
+]
+
+[[package]]
+name = "nvidia-nccl-cu12"
+version = "2.27.5"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bb/1c/857979db0ef194ca5e21478a0612bcdbbe59458d7694361882279947b349/nvidia_nccl_cu12-2.27.5-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:31432ad4d1fb1004eb0c56203dc9bc2178a1ba69d1d9e02d64a6938ab5e40e7a", size = 322400625, upload-time = "2025-06-26T04:11:04.496Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/89/f7a07dc961b60645dbbf42e80f2bc85ade7feb9a491b11a1e973aa00071f/nvidia_nccl_cu12-2.27.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ad730cf15cb5d25fe849c6e6ca9eb5b76db16a80f13f425ac68d8e2e55624457", size = 322348229, upload-time = "2025-06-26T04:11:28.385Z" },
+]
+
+[[package]]
+name = "nvidia-nvjitlink-cu12"
+version = "12.8.93"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f6/74/86a07f1d0f42998ca31312f998bd3b9a7eff7f52378f4f270c8679c77fb9/nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:81ff63371a7ebd6e6451970684f916be2eab07321b73c9d244dc2b4da7f73b88", size = 39254836, upload-time = "2025-03-07T01:49:55.661Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/a2/8cee5da30d13430e87bf99bb33455d2724d0a4a9cb5d7926d80ccb96d008/nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:adccd7161ace7261e01bb91e44e88da350895c270d23f744f0820c818b7229e7", size = 38386204, upload-time = "2025-03-07T01:49:43.612Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/d7/34f02dad2e30c31b10a51f6b04e025e5dd60e5f936af9045a9b858a05383/nvidia_nvjitlink_cu12-12.8.93-py3-none-win_amd64.whl", hash = "sha256:bd93fbeeee850917903583587f4fc3a4eafa022e34572251368238ab5e6bd67f", size = 268553710, upload-time = "2025-03-07T01:56:24.13Z" },
+]
+
+[[package]]
+name = "nvidia-nvshmem-cu12"
+version = "3.3.20"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/92/9d/3dd98852568fb845ec1f7902c90a22b240fe1cbabda411ccedf2fd737b7b/nvidia_nvshmem_cu12-3.3.20-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0b0b960da3842212758e4fa4696b94f129090b30e5122fea3c5345916545cff0", size = 124484616, upload-time = "2025-08-04T20:24:59.172Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/6c/99acb2f9eb85c29fc6f3a7ac4dccfd992e22666dd08a642b303311326a97/nvidia_nvshmem_cu12-3.3.20-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d00f26d3f9b2e3c3065be895e3059d6479ea5c638a3f38c9fec49b1b9dd7c1e5", size = 124657145, upload-time = "2025-08-04T20:25:19.995Z" },
+]
+
+[[package]]
+name = "nvidia-nvtx-cu12"
+version = "12.8.90"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/10/c0/1b303feea90d296f6176f32a2a70b5ef230f9bdeb3a72bddb0dc922dc137/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d7ad891da111ebafbf7e015d34879f7112832fc239ff0d7d776b6cb685274615", size = 91161, upload-time = "2025-03-07T01:42:23.922Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/eb/86626c1bbc2edb86323022371c39aa48df6fd8b0a1647bc274577f72e90b/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b17e2001cc0d751a5bc2c6ec6d26ad95913324a4adb86788c944f8ce9ba441f", size = 89954, upload-time = "2025-03-07T01:42:44.131Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/99/4c9c0c329bf9fc125008c3b54c7c94c0023518d06fc025ae36431375e1fe/nvidia_nvtx_cu12-12.8.90-py3-none-win_amd64.whl", hash = "sha256:619c8304aedc69f02ea82dd244541a83c3d9d40993381b3b590f1adaed3db41e", size = 56492, upload-time = "2025-03-07T01:52:24.69Z" },
+]
+
+[[package]]
+name = "onnx"
+version = "1.22.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ml-dtypes" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "protobuf" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/04/19/8ea73a64b368b75fe339771a20a02bc61ea1f551484c9e3d9d0bfbd0450f/onnx-1.22.0.tar.gz", hash = "sha256:ef40c0aaf0b643857ea9306fc7eddce17eaf9fb0407e4801f1fc5758443a38e0", size = 12024721, upload-time = "2026-06-15T12:50:05.354Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/04/471f234e2716c83f17a26e1b50cd64c39428373e91dd018aafb3d499c108/onnx-1.22.0-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:6d0ffffd63a4ecc21ddaeddd5bf02099cb701aa4243f2de00122726869065ca4", size = 20167110, upload-time = "2026-06-15T12:48:59.152Z" },
+    { url = "https://files.pythonhosted.org/packages/99/40/540a2fe3c49ce1709ff2015de20d9a351264fb442f8998f92cf0ba7e279e/onnx-1.22.0-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33ce94119bbb7f05d9caea4ea7549f5185a54369f6bbc9f70171bd5ee6935bbc", size = 18892738, upload-time = "2026-06-15T12:49:02.139Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/0c/f41d5b89c38fb2ec410ab23c24fa110af786093b140644f7f953e436743b/onnx-1.22.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:87a3077958f66f9a26dec10077ac28326d9cec2cbe1f0b040947243449754573", size = 19110354, upload-time = "2026-06-15T12:49:05.031Z" },
+    { url = "https://files.pythonhosted.org/packages/11/8e/9f41d132855e93c2808cdd4afab1b5af67bd5e82e4a4fa9248006e4df87e/onnx-1.22.0-cp310-cp310-win32.whl", hash = "sha256:8a5eccce2d5fc6c5046928a9aa7cdd9750ea4a586f8de341d3d40d820c35fdec", size = 17083595, upload-time = "2026-06-15T12:49:08.599Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/52/86caff81786a5428485795c79175ae2b12a630795bcb267b84e5f9e98450/onnx-1.22.0-cp310-cp310-win_amd64.whl", hash = "sha256:5c1c0408a9d4b4df33851672e5fc7590b96301ee123396d608f9ab6f045ab06b", size = 17215270, upload-time = "2026-06-15T12:49:11.483Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/55/30825c02c92a0380ce84c3feeeec95d329fa77548ba58cb10ad4bbfd83c6/onnx-1.22.0-cp311-cp311-macosx_12_0_universal2.whl", hash = "sha256:2d8f229a553fa440fe623ed7b36fca5e7762da3af871c3f8f8ce451df73e2914", size = 20167891, upload-time = "2026-06-15T12:49:14.212Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/24/cd4ab52ecaf41c3fbed674772ccbfe39041cb257b8471a47a37e48bff3f8/onnx-1.22.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1a89a7cb9ba13d78f009bdec448ec82a98972589734f157022a2bff7a5973a6", size = 18892720, upload-time = "2026-06-15T12:49:16.904Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/a0/c9d9d56ceadb1c0a90a7cbec5a0510520ab6538938944fa84548e4b5b054/onnx-1.22.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1d0a2bdb15eb2b3cb65c438f3423d9620d14fdce32f92380e6bb1b2e09568ef5", size = 19110720, upload-time = "2026-06-15T12:49:19.812Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/6e/e43e5a68d9cadde55df75310027f87127333a77e5ddcea14c73e96a10cac/onnx-1.22.0-cp311-cp311-win32.whl", hash = "sha256:239958534464612fbcb6ed23d5228aaa925b39b8773f58726809ffdccb4edd1c", size = 17083746, upload-time = "2026-06-15T12:49:22.935Z" },
+    { url = "https://files.pythonhosted.org/packages/54/57/cc0a9f2cf4522e42829d089927b4b75924d32f50dca237482e7b741df003/onnx-1.22.0-cp311-cp311-win_amd64.whl", hash = "sha256:8561a2c00041c07e08db0c228593b5b4694100398685f348532af7dbb84189da", size = 17215684, upload-time = "2026-06-15T12:49:26.084Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/99/0f049f9eaa06c8383060c5f0a338e3a6caac8822e6e326c9162f05abf95a/onnx-1.22.0-cp311-cp311-win_arm64.whl", hash = "sha256:8907b9b9389893bc0dc6314cc00ee1e3a69844e48d689eacc6a0340411a7da58", size = 17210398, upload-time = "2026-06-15T12:49:29.091Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/6a/481561f1093834376ed493e4ca42a73e5be0d50031f2969c86593bdc7c96/onnx-1.22.0-cp312-abi3-macosx_12_0_universal2.whl", hash = "sha256:596fbf0490947533c1c1045ba860851dc9fb77471023dac9a71ba5b42ceab103", size = 20167081, upload-time = "2026-06-15T12:49:32.078Z" },
+    { url = "https://files.pythonhosted.org/packages/84/55/b34fc2aa30aa54b4a775402d24c4082242c720283a274fe976ac8eb94480/onnx-1.22.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ae5a563f281cd9d2845622cecf6c092a57e4ee1b138f66fdbbdd4200567a5e16", size = 18889249, upload-time = "2026-06-15T12:49:34.7Z" },
+    { url = "https://files.pythonhosted.org/packages/09/a6/bd32357e6cc1ecb473afd78193d7231724f284435d2db25696ecfaaa1503/onnx-1.22.0-cp312-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:955e02e1f6d385b53d52f9cd7b9cdf5caf417c300bcfe3c64c6d542be763845b", size = 19106514, upload-time = "2026-06-15T12:49:37.424Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/9d/3af461ac6c714b8b369cb71499659932f4f12cfb066250b62f7567c3d530/onnx-1.22.0-cp312-abi3-pyemscripten_2025_0_wasm32.whl", hash = "sha256:82e9f27fc1223cb06d68a56bed6f9d3caf3d0dad1b61bce45006d529b15bd94c", size = 16966387, upload-time = "2026-06-15T12:49:40.918Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/f0/68195b5e5a53e333faf2660f5352ee43738d0e42fc5216cc6b1871a9fbfb/onnx-1.22.0-cp312-abi3-win32.whl", hash = "sha256:cc8b66b312f8f03a53e268afb67180a2d97dd12cc79e2b61361c6c0073448016", size = 17081568, upload-time = "2026-06-15T12:49:43.398Z" },
+    { url = "https://files.pythonhosted.org/packages/13/a8/734725bb703c5fabb687f79c79e51249475212b3eb37771ac4a4ac9b487f/onnx-1.22.0-cp312-abi3-win_amd64.whl", hash = "sha256:72ccebab3bac07215c204ce8848d42e78eaaa666badbf72d25cd359b9f269e3a", size = 17213290, upload-time = "2026-06-15T12:49:45.933Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/2a/8ce48d8ae26a8761ad4e5dc771961b155c5c3c7c8540ec7f2f2d71b69af0/onnx-1.22.0-cp312-abi3-win_arm64.whl", hash = "sha256:f3c120dcdb70ad738f3c061b32798f408ea299eb69f84dd69ab4a6bf3c2ec01f", size = 17207030, upload-time = "2026-06-15T12:49:48.635Z" },
+]
+
+[[package]]
+name = "onnx-ir"
+version = "0.1.11"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ml-dtypes" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "onnx" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4b/c4/d7c52d89120ae2d90025bf30999f44ec029bb297be706ada81a2b7ce3e73/onnx_ir-0.1.11.tar.gz", hash = "sha256:05fd55f7548f4301a17476c53e19c16f92f4fc4c0f468fcd8d3afb6869f8ae75", size = 112093, upload-time = "2025-10-15T22:20:46.785Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/de/a9bb49f36e2d27ff2b1941972ce01838c9032155256e3380960c6f545455/onnx_ir-0.1.11-py3-none-any.whl", hash = "sha256:f23edd0d3f49b92abfab275625cb325da3978f5b41ba8cdaa28e85e87b44d2c1", size = 128694, upload-time = "2025-10-15T22:20:45.208Z" },
+]
+
+[[package]]
+name = "onnxruntime"
+version = "1.24.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "flatbuffers", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "packaging", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "protobuf", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sympy", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/15/41/3253db975a90c3ce1d475e2a230773a21cd7998537f0657947df6fb79861/onnxruntime-1.24.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3e6456801c66b095c5cd68e690ca25db970ea5202bd0c5b84a2c3ef7731c5a3c", size = 17332766, upload-time = "2026-03-05T17:18:59.714Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/c5/3af6b325f1492d691b23844d88ed26844c1164620860c5efe95c0e22782d/onnxruntime-1.24.3-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b2ebc54c6d8281dccff78d4b06e47d4cf07535937584ab759448390a70f4978", size = 15130330, upload-time = "2026-03-05T16:34:53.831Z" },
+    { url = "https://files.pythonhosted.org/packages/03/4b/f96b46c1866a293ed23ca2cf5e5a63d413ad3a951da60dd877e3c56cbbca/onnxruntime-1.24.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fb56575d7794bf0781156955610c9e651c9504c64d42ec880784b6106244882d", size = 17213247, upload-time = "2026-03-05T17:17:59.812Z" },
+    { url = "https://files.pythonhosted.org/packages/36/13/27cf4d8df2578747584e8758aeb0b673b60274048510257f1f084b15e80e/onnxruntime-1.24.3-cp311-cp311-win_amd64.whl", hash = "sha256:c958222ef9eff54018332beecd32d5d94a3ab079d8821937b333811bf4da0d39", size = 12595530, upload-time = "2026-03-05T17:18:49.356Z" },
+    { url = "https://files.pythonhosted.org/packages/19/8c/6d9f31e6bae72a8079be12ed8ba36c4126a571fad38ded0a1b96f60f6896/onnxruntime-1.24.3-cp311-cp311-win_arm64.whl", hash = "sha256:a8f761857ebaf58a85b9e42422d03207f1d39e6bb8fecfdbf613bac5b9710723", size = 12261715, upload-time = "2026-03-05T17:18:39.699Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/7f/dfdc4e52600fde4c02d59bfe98c4b057931c1114b701e175aee311a9bc11/onnxruntime-1.24.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:0d244227dc5e00a9ae15a7ac1eba4c4460d7876dfecafe73fb00db9f1d914d91", size = 17342578, upload-time = "2026-03-05T17:19:02.403Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/dc/1f5489f7b21817d4ad352bf7a92a252bd5b438bcbaa7ad20ea50814edc79/onnxruntime-1.24.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a9847b870b6cb462652b547bc98c49e0efb67553410a082fde1918a38707452", size = 15150105, upload-time = "2026-03-05T16:34:56.897Z" },
+    { url = "https://files.pythonhosted.org/packages/28/7c/fd253da53594ab8efbefdc85b3638620ab1a6aab6eb7028a513c853559ce/onnxruntime-1.24.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b354afce3333f2859c7e8706d84b6c552beac39233bcd3141ce7ab77b4cabb5d", size = 17237101, upload-time = "2026-03-05T17:18:02.561Z" },
+    { url = "https://files.pythonhosted.org/packages/71/5f/eaabc5699eeed6a9188c5c055ac1948ae50138697a0428d562ac970d7db5/onnxruntime-1.24.3-cp312-cp312-win_amd64.whl", hash = "sha256:44ea708c34965439170d811267c51281d3897ecfc4aa0087fa25d4a4c3eb2e4a", size = 12597638, upload-time = "2026-03-05T17:18:52.141Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/5c/d8066c320b90610dbeb489a483b132c3b3879b2f93f949fb5d30cfa9b119/onnxruntime-1.24.3-cp312-cp312-win_arm64.whl", hash = "sha256:48d1092b44ca2ba6f9543892e7c422c15a568481403c10440945685faf27a8d8", size = 12270943, upload-time = "2026-03-05T17:18:42.006Z" },
+    { url = "https://files.pythonhosted.org/packages/51/8d/487ece554119e2991242d4de55de7019ac6e47ee8dfafa69fcf41d37f8ed/onnxruntime-1.24.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:34a0ea5ff191d8420d9c1332355644148b1bf1a0d10c411af890a63a9f662aa7", size = 17342706, upload-time = "2026-03-05T16:35:10.813Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/25/8b444f463c1ac6106b889f6235c84f01eec001eaf689c3eff8c69cf48fae/onnxruntime-1.24.3-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fd2ec7bb0fabe42f55e8337cfc9b1969d0d14622711aac73d69b4bd5abb5ed7", size = 15149956, upload-time = "2026-03-05T16:34:59.264Z" },
+    { url = "https://files.pythonhosted.org/packages/34/fc/c9182a3e1ab46940dd4f30e61071f59eee8804c1f641f37ce6e173633fb6/onnxruntime-1.24.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:df8e70e732fe26346faaeec9147fa38bef35d232d2495d27e93dd221a2d473a9", size = 17237370, upload-time = "2026-03-05T17:18:05.258Z" },
+    { url = "https://files.pythonhosted.org/packages/05/7e/3b549e1f4538514118bff98a1bcd6481dd9a17067f8c9af77151621c9a5c/onnxruntime-1.24.3-cp313-cp313-win_amd64.whl", hash = "sha256:2d3706719be6ad41d38a2250998b1d87758a20f6ea4546962e21dc79f1f1fd2b", size = 12597939, upload-time = "2026-03-05T17:18:54.772Z" },
+    { url = "https://files.pythonhosted.org/packages/80/41/9696a5c4631a0caa75cc8bc4efd30938fd483694aa614898d087c3ee6d29/onnxruntime-1.24.3-cp313-cp313-win_arm64.whl", hash = "sha256:b082f3ba9519f0a1a1e754556bc7e635c7526ef81b98b3f78da4455d25f0437b", size = 12270705, upload-time = "2026-03-05T17:18:44.774Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/65/a26c5e59e3b210852ee04248cf8843c81fe7d40d94cf95343b66efe7eec9/onnxruntime-1.24.3-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72f956634bc2e4bd2e8b006bef111849bd42c42dea37bd0a4c728404fdaf4d34", size = 15161796, upload-time = "2026-03-05T16:35:02.871Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/25/2035b4aa2ccb5be6acf139397731ec507c5f09e199ab39d3262b22ffa1ac/onnxruntime-1.24.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:78d1f25eed4ab9959db70a626ed50ee24cf497e60774f59f1207ac8556399c4d", size = 17240936, upload-time = "2026-03-05T17:18:09.534Z" },
+]
+
+[[package]]
+name = "onnxscript"
+version = "0.5.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ml-dtypes" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "onnx" },
+    { name = "onnx-ir" },
+    { name = "packaging" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b2/88/c3fad7bcb0f57c6f7795e28c479545cd47ca9109b174765f7cca0121148e/onnxscript-0.5.4.tar.gz", hash = "sha256:311e08ce513484a1fadfc19f3ad28f83ed41a8ce73eca4d038cd3623f6f52104", size = 584052, upload-time = "2025-10-16T17:55:27.615Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9d/b2/bd42c04bd731769667df20de57f80b9753dbffb72bb24fddf4bb87a65433/onnxscript-0.5.4-py3-none-any.whl", hash = "sha256:640d2aa55364b9b0d66c280cc4b22cd2c918fde9a1a72c2460d2fbe24b9181dc", size = 679346, upload-time = "2025-10-16T17:55:29.886Z" },
+]
+
+[[package]]
+name = "orjson"
+version = "3.11.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/1b/2024d06792d0779f9dbc51531b61c24f76c75b9f4ce05e6f3377a1814cea/orjson-3.11.8.tar.gz", hash = "sha256:96163d9cdc5a202703e9ad1b9ae757d5f0ca62f4fa0cc93d1f27b0e180cc404e", size = 5603832, upload-time = "2026-03-31T16:16:27.878Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2f/90/5d81f61fe3e4270da80c71442864c091cee3003cc8984c75f413fe742a07/orjson-3.11.8-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:e6693ff90018600c72fd18d3d22fa438be26076cd3c823da5f63f7bab28c11cb", size = 229663, upload-time = "2026-03-31T16:14:30.708Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/ef/85e06b0eb11de6fb424120fd5788a07035bd4c5e6bb7841ae9972a0526d1/orjson-3.11.8-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93de06bc920854552493c81f1f729fab7213b7db4b8195355db5fda02c7d1363", size = 132321, upload-time = "2026-03-31T16:14:32.317Z" },
+    { url = "https://files.pythonhosted.org/packages/86/71/089338ee51b3132f050db0864a7df9bdd5e94c2a03820ab8a91e8f655618/orjson-3.11.8-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fe0b8c83e0f36247fc9431ce5425a5d95f9b3a689133d494831bdbd6f0bceb13", size = 130658, upload-time = "2026-03-31T16:14:33.935Z" },
+    { url = "https://files.pythonhosted.org/packages/10/0d/f39d8802345d0ad65f7fd4374b29b9b59f98656dc30f21ca5c773265b2f0/orjson-3.11.8-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:97d823831105c01f6c8029faf297633dbeb30271892bd430e9c24ceae3734744", size = 135708, upload-time = "2026-03-31T16:14:35.224Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b5/40aae576b3473511696dcffea84fde638b2b64774eb4dcb8b2c262729f8a/orjson-3.11.8-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c60c0423f15abb6cf78f56dff00168a1b582f7a1c23f114036e2bfc697814d5f", size = 147047, upload-time = "2026-03-31T16:14:36.489Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/f0/778a84458d1fdaa634b2e572e51ce0b354232f580b2327e1f00a8d88c38c/orjson-3.11.8-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:01928d0476b216ad2201823b0a74000440360cef4fed1912d297b8d84718f277", size = 133072, upload-time = "2026-03-31T16:14:37.715Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/d3/1bbf2fc3ffcc4b829ade554b574af68cec898c9b5ad6420a923c75a073d3/orjson-3.11.8-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6a4a639049c44d36a6d1ae0f4a94b271605c745aee5647fa8ffaabcdc01b69a6", size = 133867, upload-time = "2026-03-31T16:14:39.356Z" },
+    { url = "https://files.pythonhosted.org/packages/08/94/6413da22edc99a69a8d0c2e83bf42973b8aa94d83ef52a6d39ac85da00bc/orjson-3.11.8-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3222adff1e1ff0dce93c16146b93063a7793de6c43d52309ae321234cdaf0f4d", size = 142268, upload-time = "2026-03-31T16:14:40.972Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/5f/aa5dbaa6136d7ba55f5461ac2e885efc6e6349424a428927fd46d68f4396/orjson-3.11.8-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:3223665349bbfb68da234acd9846955b1a0808cbe5520ff634bf253a4407009b", size = 424008, upload-time = "2026-03-31T16:14:42.637Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/aa/2c1962d108c7fe5e27aa03a354b378caf56d8eafdef15fd83dec081ce45a/orjson-3.11.8-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:61c9d357a59465736022d5d9ba06687afb7611dfb581a9d2129b77a6fcf78e59", size = 147942, upload-time = "2026-03-31T16:14:44.256Z" },
+    { url = "https://files.pythonhosted.org/packages/47/d1/65f404f4c47eb1b0b4476f03ec838cac0c4aa933920ff81e5dda4dee14e7/orjson-3.11.8-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:58fb9b17b4472c7b1dcf1a54583629e62e23779b2331052f09a9249edf81675b", size = 136640, upload-time = "2026-03-31T16:14:45.884Z" },
+    { url = "https://files.pythonhosted.org/packages/90/5f/7b784aea98bdb125a2f2da7c27d6c2d2f6d943d96ef0278bae596d563f85/orjson-3.11.8-cp310-cp310-win32.whl", hash = "sha256:b43dc2a391981d36c42fa57747a49dae793ef1d2e43898b197925b5534abd10a", size = 132066, upload-time = "2026-03-31T16:14:47.397Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ec/2e284af8d6c9478df5ef938917743f61d68f4c70d17f1b6e82f7e3b8dba1/orjson-3.11.8-cp310-cp310-win_amd64.whl", hash = "sha256:c98121237fea2f679480765abd566f7713185897f35c9e6c2add7e3a9900eb61", size = 127609, upload-time = "2026-03-31T16:14:48.78Z" },
+    { url = "https://files.pythonhosted.org/packages/67/41/5aa7fa3b0f4dc6b47dcafc3cea909299c37e40e9972feabc8b6a74e2730d/orjson-3.11.8-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:003646067cc48b7fcab2ae0c562491c9b5d2cbd43f1e5f16d98fd118c5522d34", size = 229229, upload-time = "2026-03-31T16:14:50.424Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/d7/57e7f2458e0a2c41694f39fc830030a13053a84f837a5b73423dca1f0938/orjson-3.11.8-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:ed193ce51d77a3830cad399a529cd4ef029968761f43ddc549e1bc62b40d88f8", size = 128871, upload-time = "2026-03-31T16:14:51.888Z" },
+    { url = "https://files.pythonhosted.org/packages/53/4a/e0fdb9430983e6c46e0299559275025075568aad5d21dd606faee3703924/orjson-3.11.8-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f30491bc4f862aa15744b9738517454f1e46e56c972a2be87d70d727d5b2a8f8", size = 132104, upload-time = "2026-03-31T16:14:53.142Z" },
+    { url = "https://files.pythonhosted.org/packages/08/4a/2025a60ff3f5c8522060cda46612d9b1efa653de66ed2908591d8d82f22d/orjson-3.11.8-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6eda5b8b6be91d3f26efb7dc6e5e68ee805bc5617f65a328587b35255f138bf4", size = 130483, upload-time = "2026-03-31T16:14:54.605Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/3c/b9cde05bdc7b2385c66014e0620627da638d3d04e4954416ab48c31196c5/orjson-3.11.8-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ee8db7bfb6fe03581bbab54d7c4124a6dd6a7f4273a38f7267197890f094675f", size = 135481, upload-time = "2026-03-31T16:14:55.901Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/f2/a8238e7734de7cb589fed319857a8025d509c89dc52fdcc88f39c6d03d5a/orjson-3.11.8-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5d8b5231de76c528a46b57010bbd83fb51e056aa0220a372fd5065e978406f1c", size = 146819, upload-time = "2026-03-31T16:14:57.548Z" },
+    { url = "https://files.pythonhosted.org/packages/db/10/dbf1e2a3cafea673b1b4350e371877b759060d6018a998643b7040e5de48/orjson-3.11.8-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:58a4a208a6fbfdb7a7327b8f201c6014f189f721fd55d047cafc4157af1bc62a", size = 132846, upload-time = "2026-03-31T16:14:58.91Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/fc/55e667ec9c85694038fcff00573d221b085d50777368ee3d77f38668bf3c/orjson-3.11.8-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5f8952d6d2505c003e8f0224ff7858d341fa4e33fef82b91c4ff0ef070f2393c", size = 133580, upload-time = "2026-03-31T16:15:00.519Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/a6/c08c589a9aad0cb46c4831d17de212a2b6901f9d976814321ff8e69e8785/orjson-3.11.8-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0022bb50f90da04b009ce32c512dc1885910daa7cb10b7b0cba4505b16db82a8", size = 142042, upload-time = "2026-03-31T16:15:01.906Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/cc/2f78ea241d52b717d2efc38878615fe80425bf2beb6e68c984dde257a766/orjson-3.11.8-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ff51f9d657d1afb6f410cb435792ce4e1fe427aab23d2fcd727a2876e21d4cb6", size = 423845, upload-time = "2026-03-31T16:15:03.703Z" },
+    { url = "https://files.pythonhosted.org/packages/70/07/c17dcf05dd8045457538428a983bf1f1127928df5bf328cb24d2b7cddacb/orjson-3.11.8-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:6dbe9a97bdb4d8d9d5367b52a7c32549bba70b2739c58ef74a6964a6d05ae054", size = 147729, upload-time = "2026-03-31T16:15:05.203Z" },
+    { url = "https://files.pythonhosted.org/packages/90/6c/0fb6e8a24e682e0958d71711ae6f39110e4b9cd8cab1357e2a89cb8e1951/orjson-3.11.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a5c370674ebabe16c6ccac33ff80c62bf8a6e59439f5e9d40c1f5ab8fd2215b7", size = 136425, upload-time = "2026-03-31T16:15:07.052Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/35/4d3cc3a3d616035beb51b24a09bb872942dc452cf2df0c1d11ab35046d9f/orjson-3.11.8-cp311-cp311-win32.whl", hash = "sha256:0e32f7154299f42ae66f13488963269e5eccb8d588a65bc839ed986919fc9fac", size = 131870, upload-time = "2026-03-31T16:15:08.678Z" },
+    { url = "https://files.pythonhosted.org/packages/13/26/9fe70f81d16b702f8c3a775e8731b50ad91d22dacd14c7599b60a0941cd1/orjson-3.11.8-cp311-cp311-win_amd64.whl", hash = "sha256:25e0c672a2e32348d2eb33057b41e754091f2835f87222e4675b796b92264f06", size = 127440, upload-time = "2026-03-31T16:15:09.994Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/c6/b038339f4145efd2859c1ca53097a52c0bb9cbdd24f947ebe146da1ad067/orjson-3.11.8-cp311-cp311-win_arm64.whl", hash = "sha256:9185589c1f2a944c17e26c9925dcdbc2df061cc4a145395c57f0c51f9b5dbfcd", size = 127399, upload-time = "2026-03-31T16:15:11.412Z" },
+    { url = "https://files.pythonhosted.org/packages/01/f6/8d58b32ab32d9215973a1688aebd098252ee8af1766c0e4e36e7831f0295/orjson-3.11.8-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:1cd0b77e77c95758f8e1100139844e99f3ccc87e71e6fc8e1c027e55807c549f", size = 229233, upload-time = "2026-03-31T16:15:12.762Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/8b/2ffe35e71f6b92622e8ea4607bf33ecf7dfb51b3619dcfabfd36cbe2d0a5/orjson-3.11.8-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:6a3d159d5ffa0e3961f353c4b036540996bf8b9697ccc38261c0eac1fd3347a6", size = 128772, upload-time = "2026-03-31T16:15:14.237Z" },
+    { url = "https://files.pythonhosted.org/packages/27/d2/1f8682ae50d5c6897a563cb96bc106da8c9cb5b7b6e81a52e4cc086679b9/orjson-3.11.8-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76070a76e9c5ae661e2d9848f216980d8d533e0f8143e6ed462807b242e3c5e8", size = 131946, upload-time = "2026-03-31T16:15:15.607Z" },
+    { url = "https://files.pythonhosted.org/packages/52/4b/5500f76f0eece84226e0689cb48dcde081104c2fa6e2483d17ca13685ffb/orjson-3.11.8-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:54153d21520a71a4c82a0dbb4523e468941d549d221dc173de0f019678cf3813", size = 130368, upload-time = "2026-03-31T16:15:17.066Z" },
+    { url = "https://files.pythonhosted.org/packages/da/4e/58b927e08fbe9840e6c920d9e299b051ea667463b1f39a56e668669f8508/orjson-3.11.8-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:469ac2125611b7c5741a0b3798cd9e5786cbad6345f9f400c77212be89563bec", size = 135540, upload-time = "2026-03-31T16:15:18.404Z" },
+    { url = "https://files.pythonhosted.org/packages/56/7c/ba7cb871cba1bcd5cd02ee34f98d894c6cea96353ad87466e5aef2429c60/orjson-3.11.8-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:14778ffd0f6896aa613951a7fbf4690229aa7a543cb2bfbe9f358e08aafa9546", size = 146877, upload-time = "2026-03-31T16:15:19.833Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/5d/eb9c25fc1386696c6a342cd361c306452c75e0b55e86ad602dd4827a7fd7/orjson-3.11.8-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ea56a955056a6d6c550cf18b3348656a9d9a4f02e2d0c02cabf3c73f1055d506", size = 132837, upload-time = "2026-03-31T16:15:21.282Z" },
+    { url = "https://files.pythonhosted.org/packages/37/87/5ddeb7fc1fbd9004aeccab08426f34c81a5b4c25c7061281862b015fce2b/orjson-3.11.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:53a0f57e59a530d18a142f4d4ba6dfc708dc5fdedce45e98ff06b44930a2a48f", size = 133624, upload-time = "2026-03-31T16:15:22.641Z" },
+    { url = "https://files.pythonhosted.org/packages/22/09/90048793db94ee4b2fcec4ac8e5ddb077367637d6650be896b3494b79bb7/orjson-3.11.8-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9b48e274f8824567d74e2158199e269597edf00823a1b12b63d48462bbf5123e", size = 141904, upload-time = "2026-03-31T16:15:24.435Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/cf/eb284847487821a5d415e54149a6449ba9bfc5872ce63ab7be41b8ec401c/orjson-3.11.8-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:3f262401086a3960586af06c054609365e98407151f5ea24a62893a40d80dbbb", size = 423742, upload-time = "2026-03-31T16:15:26.155Z" },
+    { url = "https://files.pythonhosted.org/packages/44/09/e12423d327071c851c13e76936f144a96adacfc037394dec35ac3fc8d1e8/orjson-3.11.8-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8e8c6218b614badf8e229b697865df4301afa74b791b6c9ade01d19a9953a942", size = 147806, upload-time = "2026-03-31T16:15:27.909Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/6d/37c2589ba864e582ffe7611643314785c6afb1f83c701654ef05daa8fcc7/orjson-3.11.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:093d489fa039ddade2db541097dbb484999fcc65fc2b0ff9819141e2ab364f25", size = 136485, upload-time = "2026-03-31T16:15:29.749Z" },
+    { url = "https://files.pythonhosted.org/packages/be/c9/135194a02ab76b04ed9a10f68624b7ebd238bbe55548878b11ff15a0f352/orjson-3.11.8-cp312-cp312-win32.whl", hash = "sha256:e0950ed1bcb9893f4293fd5c5a7ee10934fbf82c4101c70be360db23ce24b7d2", size = 131966, upload-time = "2026-03-31T16:15:31.687Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/9a/9796f8fbe3cf30ce9cb696748dbb535e5c87be4bf4fe2e9ca498ef1fa8cf/orjson-3.11.8-cp312-cp312-win_amd64.whl", hash = "sha256:3cf17c141617b88ced4536b2135c552490f07799f6ad565948ea07bef0dcb9a6", size = 127441, upload-time = "2026-03-31T16:15:33.333Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/47/5aaf54524a7a4a0dd09dd778f3fa65dd2108290615b652e23d944152bc8e/orjson-3.11.8-cp312-cp312-win_arm64.whl", hash = "sha256:48854463b0572cc87dac7d981aa72ed8bf6deedc0511853dc76b8bbd5482d36d", size = 127364, upload-time = "2026-03-31T16:15:34.748Z" },
+    { url = "https://files.pythonhosted.org/packages/66/7f/95fba509bb2305fab0073558f1e8c3a2ec4b2afe58ed9fcb7d3b8beafe94/orjson-3.11.8-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:3f23426851d98478c8970da5991f84784a76682213cd50eb73a1da56b95239dc", size = 229180, upload-time = "2026-03-31T16:15:36.426Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/9d/b237215c743ca073697d759b5503abd2cb8a0d7b9c9e21f524bcf176ab66/orjson-3.11.8-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:ebaed4cef74a045b83e23537b52ef19a367c7e3f536751e355a2a394f8648559", size = 128754, upload-time = "2026-03-31T16:15:38.049Z" },
+    { url = "https://files.pythonhosted.org/packages/42/3d/27d65b6d11e63f133781425f132807aef793ed25075fec686fc8e46dd528/orjson-3.11.8-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:97c8f5d3b62380b70c36ffacb2a356b7c6becec86099b177f73851ba095ef623", size = 131877, upload-time = "2026-03-31T16:15:39.484Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/cc/faee30cd8f00421999e40ef0eba7332e3a625ce91a58200a2f52c7fef235/orjson-3.11.8-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:436c4922968a619fb7fef1ccd4b8b3a76c13b67d607073914d675026e911a65c", size = 130361, upload-time = "2026-03-31T16:15:41.274Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/bb/a6c55896197f97b6d4b4e7c7fd77e7235517c34f5d6ad5aadd43c54c6d7c/orjson-3.11.8-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1ab359aff0436d80bfe8a23b46b5fea69f1e18aaf1760a709b4787f1318b317f", size = 135521, upload-time = "2026-03-31T16:15:42.758Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/7c/ca3a3525aa32ff636ebb1778e77e3587b016ab2edb1b618b36ba96f8f2c0/orjson-3.11.8-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f89b6d0b3a8d81e1929d3ab3d92bbc225688bd80a770c49432543928fe09ac55", size = 146862, upload-time = "2026-03-31T16:15:44.341Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0c/18a9d7f18b5edd37344d1fd5be17e94dc652c67826ab749c6e5948a78112/orjson-3.11.8-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:29c009e7a2ca9ad0ed1376ce20dd692146a5d9fe4310848904b6b4fee5c5c137", size = 132847, upload-time = "2026-03-31T16:15:46.368Z" },
+    { url = "https://files.pythonhosted.org/packages/23/91/7e722f352ad67ca573cee44de2a58fb810d0f4eb4e33276c6a557979fd8a/orjson-3.11.8-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:705b895b781b3e395c067129d8551655642dfe9437273211d5404e87ac752b53", size = 133637, upload-time = "2026-03-31T16:15:48.123Z" },
+    { url = "https://files.pythonhosted.org/packages/af/04/32845ce13ac5bd1046ddb02ac9432ba856cc35f6d74dde95864fe0ad5523/orjson-3.11.8-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:88006eda83858a9fdf73985ce3804e885c2befb2f506c9a3723cdeb5a2880e3e", size = 141906, upload-time = "2026-03-31T16:15:49.626Z" },
+    { url = "https://files.pythonhosted.org/packages/02/5e/c551387ddf2d7106d9039369862245c85738b828844d13b99ccb8d61fd06/orjson-3.11.8-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:55120759e61309af7fcf9e961c6f6af3dde5921cdb3ee863ef63fd9db126cae6", size = 423722, upload-time = "2026-03-31T16:15:51.176Z" },
+    { url = "https://files.pythonhosted.org/packages/00/a3/ecfe62434096f8a794d4976728cb59bcfc4a643977f21c2040545d37eb4c/orjson-3.11.8-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:98bdc6cb889d19bed01de46e67574a2eab61f5cc6b768ed50e8ac68e9d6ffab6", size = 147801, upload-time = "2026-03-31T16:15:52.939Z" },
+    { url = "https://files.pythonhosted.org/packages/18/6d/0dce10b9f6643fdc59d99333871a38fa5a769d8e2fc34a18e5d2bfdee900/orjson-3.11.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:708c95f925a43ab9f34625e45dcdadf09ec8a6e7b664a938f2f8d5650f6c090b", size = 136460, upload-time = "2026-03-31T16:15:54.431Z" },
+    { url = "https://files.pythonhosted.org/packages/01/d6/6dde4f31842d87099238f1f07b459d24edc1a774d20687187443ab044191/orjson-3.11.8-cp313-cp313-win32.whl", hash = "sha256:01c4e5a6695dc09098f2e6468a251bc4671c50922d4d745aff1a0a33a0cf5b8d", size = 131956, upload-time = "2026-03-31T16:15:56.081Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/f9/4e494a56e013db957fb77186b818b916d4695b8fa2aa612364974160e91b/orjson-3.11.8-cp313-cp313-win_amd64.whl", hash = "sha256:c154a35dd1330707450bb4d4e7dd1f17fa6f42267a40c1e8a1daa5e13719b4b8", size = 127410, upload-time = "2026-03-31T16:15:57.54Z" },
+    { url = "https://files.pythonhosted.org/packages/57/7f/803203d00d6edb6e9e7eef421d4e1adbb5ea973e40b3533f3cfd9aeb374e/orjson-3.11.8-cp313-cp313-win_arm64.whl", hash = "sha256:4861bde57f4d253ab041e374f44023460e60e71efaa121f3c5f0ed457c3a701e", size = 127338, upload-time = "2026-03-31T16:15:59.106Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+]
+
+[[package]]
+name = "paramiko"
+version = "5.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "bcrypt" },
+    { name = "cryptography" },
+    { name = "invoke" },
+    { name = "pynacl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/93/dcc25d52f49022ae6175d15e6bd751f1acc99b98bc61fc55e5155a7be2e7/paramiko-5.0.0.tar.gz", hash = "sha256:36763b5b95c2a0dcfdf1abc48e48156ee425b21efe2f0e787c2dd5a95c0e5e79", size = 1548586, upload-time = "2026-05-09T18:28:52.256Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/82/5b/eadf6d45de38d30ab603f49393b6cd2cbe7e233af8cf90197e32782b68a9/paramiko-5.0.0-py3-none-any.whl", hash = "sha256:b7044611c30140d9a75261653210e2002977b71a0497ff3ba0d98d7edbf62f7c", size = 208919, upload-time = "2026-05-09T18:28:50.295Z" },
+]
+
+[[package]]
+name = "parso"
+version = "0.8.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d4/de/53e0bcf53d13e005bd8c92e7855142494f41171b34c2536b86187474184d/parso-0.8.5.tar.gz", hash = "sha256:034d7354a9a018bdce352f48b2a8a450f05e9d6ee85db84764e9b6bd96dafe5a", size = 401205, upload-time = "2025-08-23T15:15:28.028Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/16/32/f8e3c85d1d5250232a5d3477a2a28cc291968ff175caeadaf3cc19ce0e4a/parso-0.8.5-py2.py3-none-any.whl", hash = "sha256:646204b5ee239c396d040b90f9e272e9a8017c630092bf59980beb62fd033887", size = 106668, upload-time = "2025-08-23T15:15:25.663Z" },
+]
+
+[[package]]
+name = "pexpect"
+version = "4.9.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ptyprocess" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" },
+]
+
+[[package]]
+name = "pillow"
+version = "12.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", hash = "sha256:3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce", size = 47025035, upload-time = "2026-07-01T11:56:38.965Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/25/c2/669d88644cddb1485bd9534e63e8cf476c8e51cb3c3a1297677023505c0e/pillow-12.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:6c0016e7b354317c4e9e525b937ac8596c38d2d232b419529b9cd7a1cd46e39a", size = 5392418, upload-time = "2026-07-01T11:53:27.808Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/ba/3762f376a2948e3036488d773a146e0ae6ecc2ca03ac20e2615bd0b2ba02/pillow-12.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:bcc33feacfaefce60c12fd500a277533bdc02b10a19f7f6d348763d8140bbba7", size = 4785287, upload-time = "2026-07-01T11:53:29.761Z" },
+    { url = "https://files.pythonhosted.org/packages/07/50/b5d688cc9c52d4482f3d5bcab6ce20bc2a74a85d2343841c907444a3be2c/pillow-12.3.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5594fc43d548a7ed94949d139aa1341b270f1863f11cfd37f5a6c8b778a6b67f", size = 6253754, upload-time = "2026-07-01T11:53:32.298Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/89/36f4cd76cf4baf05c50ababb976249153f18c959171c7f6ba09a6f217260/pillow-12.3.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f0606c8bf2cdefea14a43530f7657cbbb7ecf1c4222512492ef4a4434a9501ec", size = 6925605, upload-time = "2026-07-01T11:53:34.487Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/c0/4de58cf6633b9e3a6061ef4be6fb91fc3c90b812ece886f531e3c523d777/pillow-12.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:85f998ea1848bc6757289e739cfbdda3a04adfd58b02fc018ce54d754a5ce468", size = 6327788, upload-time = "2026-07-01T11:53:36.433Z" },
+    { url = "https://files.pythonhosted.org/packages/87/3c/14d53682a19550dbbaf3b598f807d5457646c510805a44c7d7891cd1cd1a/pillow-12.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:25b9b82bb22e6e2b3cd07b39c68b7b862001226cb3dff7130d1cb914121b39ed", size = 7036288, upload-time = "2026-07-01T11:53:38.712Z" },
+    { url = "https://files.pythonhosted.org/packages/38/1d/36279e3c77efe034e4cc2b0393ee74ffdb5a62391dacbf9b916154f5f0b8/pillow-12.3.0-cp310-cp310-win32.whl", hash = "sha256:37dc8f7bbb66efe481bb60defacef820c950c24713fb44962ed6aa2a50966de1", size = 6472396, upload-time = "2026-07-01T11:53:40.781Z" },
+    { url = "https://files.pythonhosted.org/packages/48/7c/8fa0039574c476d7c6fa57dd7c32a130436877c6ec1e5ce1cc8ec44878c1/pillow-12.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:300557495eb45ebb8aec96c2da9c4be642fbf7cd937278b4013ba894ea8eb0eb", size = 7226887, upload-time = "2026-07-01T11:53:42.764Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/17/e324be141d173c1c919428066c3259f21c1b8982e564e01a4a81e96dbdcf/pillow-12.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:514435a37670e3e5e08f3945b68718b6ed329bb84367777e16f9f4dfe1e61a0f", size = 2568039, upload-time = "2026-07-01T11:53:45.372Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/c8/0a78b0e02d7ac54bc03e5321c9220da52f0c2ea83b21f7c40e7f3169c502/pillow-12.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:00808c5e14ef63ac5161091d242999076604ff74b883423a11e5d7bbb38bf756", size = 5392415, upload-time = "2026-07-01T11:53:47.162Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/5b/a02d30018abd97ced9f5a6c63d28597694a00d066516b9c1c6de45859fc9/pillow-12.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:37d6d0a00072fd2948eb22bce7e1475f34569d90c87c59f7a2ec59541b77f7a6", size = 4785266, upload-time = "2026-07-01T11:53:49.079Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/98/766667a4be768150a202836acd9fad19c06824ca86c4286d3cf6b274964e/pillow-12.3.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bcb46e2f9feff8d06323983bd83ed00c201fdcab3d74973e7072a889b3979fcd", size = 6263814, upload-time = "2026-07-01T11:53:51.32Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/2d/ede717bc1144f63886c21fd349bb95860b0d1a21149ff16f2bb362b612b6/pillow-12.3.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23d27a3e0307ec2244cc51e7287b919aa68d097504ebe19df4e76a98a3eea5bd", size = 6934408, upload-time = "2026-07-01T11:53:53.487Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/48/9c58b685e69d49c31af6c8eb9012055fab7e665785165c84796e2c73ce72/pillow-12.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4f883547d4b7f0495ebe7056b0cc2aea76094e7a4abc8e933540f3271df27d9c", size = 6337160, upload-time = "2026-07-01T11:53:55.457Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/fa/dc2a5c0ba6df93f67c31d34b808b7ce440b40cdbf96f0b81cde1d1e6fa93/pillow-12.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:236ff70b9312fb68943c703aa842ca6a758abfa45ac187a5e7c1452e96ef72b5", size = 7045172, upload-time = "2026-07-01T11:53:57.736Z" },
+    { url = "https://files.pythonhosted.org/packages/86/a5/444817a4d4c4c2417df00513086ca196f388d8f9ef40c2e4ccd1ad1af54b/pillow-12.3.0-cp311-cp311-win32.whl", hash = "sha256:10e41f0fbf1eec8cfd234b8fe17a4caac7c9d0db4c204d3c173a8f9f6ef3232b", size = 6472232, upload-time = "2026-07-01T11:53:59.767Z" },
+    { url = "https://files.pythonhosted.org/packages/63/c6/4bad1b18d132a50b27e1365e1ab163616f7a5bb56d330f66f9d1d9d4f9d4/pillow-12.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:8e95e1385e4998ae9694eeaa4730ba5457ff61185b3a55e2e7bea0880aef452a", size = 7233653, upload-time = "2026-07-01T11:54:02.066Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/16/00f91ab7760dc842f5aad55217e80fc4a7067a0604535249bc8a2d6d9870/pillow-12.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:ebaea975e03d3141d9d3a507df75c9b3ec90fa9d2ffd07567b3a978d9d790b26", size = 2568195, upload-time = "2026-07-01T11:54:04.622Z" },
+    { url = "https://files.pythonhosted.org/packages/37/bf/fb3ebff8ddcb76aac5a01389251bbbb9519922a9b520d8247c1ca864a25d/pillow-12.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ba09209fbe443b4acccebe845d8a138b89a8f4fbaeedd44953490b5315d5e965", size = 5345969, upload-time = "2026-07-01T11:54:06.397Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/66/9a386a92561f402389a4fc70c18838bf6d35eb5eb5c6850b4b2dc64f5048/pillow-12.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffd0c5368496f41b0944be820fcb7a838aa6e623d250b01acf2643939c3f99d7", size = 4780323, upload-time = "2026-07-01T11:54:09.351Z" },
+    { url = "https://files.pythonhosted.org/packages/25/27/ac8f99618ffd3dde21db0f4d4b1d2ab00c0880595bfd17df103f7f39fd0c/pillow-12.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d9c7f76c0673154f044e9d78c8655fb4213f6ca31a836df48b40fe5d187717b9", size = 6266838, upload-time = "2026-07-01T11:54:11.71Z" },
+    { url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91", size = 6940830, upload-time = "2026-07-01T11:54:13.732Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/51/8b08617af3ad95e33ce6d7dd2c99ed6c8298f7fb131636303956be022e25/pillow-12.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e491916b378fba47242221bb9ead245211b70d504f495d105d17b14a24b4907c", size = 6344383, upload-time = "2026-07-01T11:54:15.756Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/72/cf78ac9780bb93c28328f408973845a309d4d145041665f734572ced1b52/pillow-12.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0dd2064cbc55aaec028ef5fbb60fa47bb6c3e7918e07ff17935284b227a9d2df", size = 7052934, upload-time = "2026-07-01T11:54:17.721Z" },
+    { url = "https://files.pythonhosted.org/packages/20/20/25e0f4dc178a6bc0696793720055519a0de89e7661dae886992decbd2f81/pillow-12.3.0-cp312-cp312-win32.whl", hash = "sha256:dbce0b29841537a2fa4a214c2bbf14de3587c9680caa9b4e217568472490b28f", size = 6472684, upload-time = "2026-07-01T11:54:19.839Z" },
+    { url = "https://files.pythonhosted.org/packages/45/89/da2f7971a317f83d807fdd4065c0af40208e59e692cc43d315a71a0e96d1/pillow-12.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a2b55dd6b2a4c4b7d87ffa56bdb33fdc5fdb9a462173861a7bc097f17d91cb09", size = 7227137, upload-time = "2026-07-01T11:54:22.025Z" },
+    { url = "https://files.pythonhosted.org/packages/de/47/4845a0a6c0dbf1db8456bd9fc791f13c5ced7ced20606d08a0aacfd25b49/pillow-12.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:331b624368d4f1d069149002f25f44bc61c8919ce8ddb3c45bdad8f6e2d89510", size = 2568267, upload-time = "2026-07-01T11:54:24.051Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/ac/31fb64e1e7efb5a4b50cd3d92049ba89ac6e4d8d3bb6a74e15048ca3353e/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:21900ce7ba264168cd50defae43cd75d25c833ad4ad6e73ffc5596d12e25ac89", size = 4161684, upload-time = "2026-07-01T11:54:25.934Z" },
+    { url = "https://files.pythonhosted.org/packages/87/b4/9805e23d2b4d77842b468513841fda254ee42f0289d25088340e4ff46e2d/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4e8c2a84d977f50b9daed6eeaf3baef67d00d5d74d932288f02cb94518ee3ace", size = 4255487, upload-time = "2026-07-01T11:54:27.935Z" },
+    { url = "https://files.pythonhosted.org/packages/df/39/ecf519435a200c693fe053a6ee4d835b41cf963a4dfc2551c4e637cb2a71/pillow-12.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:ae26d61dfa7a47befdc7572b521024e8745f3d809bd95ca9505a7bba9ef849ec", size = 3696433, upload-time = "2026-07-01T11:54:29.813Z" },
+    { url = "https://files.pythonhosted.org/packages/42/92/2fc3ffad878ae8dd5469ec1bc8eb83b71f48e13efdf68f02709003982a32/pillow-12.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7a743ff716f746fc19a9557f60dab1600d4613255f8a7aeb3cdde4db7eb15a66", size = 5345889, upload-time = "2026-07-01T11:54:31.97Z" },
+    { url = "https://files.pythonhosted.org/packages/10/76/8803c13605b763d33d156c4678fc77f8443389c0c51c8aef707bb02015f4/pillow-12.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d69141514cc30b774ceea5e3ed3a6635c8d8a96edf664689b890f4089111fb35", size = 4780109, upload-time = "2026-07-01T11:54:34.026Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/01/e18aff37cb0b4aac47ac90f016d347a49aca667ef97f190b06ac2aabc928/pillow-12.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f7401aebd7f581d7f83a439d87d474999317ee099218e5ad25d125290990ba65", size = 6263736, upload-time = "2026-07-01T11:54:36.131Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/62/de5bdd77d935331f4f802edc11e4d82950f642caad6cb2f949837b8560e2/pillow-12.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0847a763afefb695bc912d7c131e7e0632d4edc1d8698f58ddabec8e46b8b6d3", size = 6937129, upload-time = "2026-07-01T11:54:38.216Z" },
+    { url = "https://files.pythonhosted.org/packages/70/4d/105627a13300c5e0df1d174230b32fd1273062c96f7745fd552b945d1e1d/pillow-12.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:571b9fcb07b97ef3a492028fb3d2dc0993ca23a06138b0315286566d29ef718a", size = 6339562, upload-time = "2026-07-01T11:54:40.354Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/1d/f13de01a553988ab895ba1c722e06cf3144d4f57656fd5b81b6d881f1179/pillow-12.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:756c768d0c9c2955feb7a56c37ea24aea2e369f8d36a88da270b6a9f19e62b5e", size = 7049439, upload-time = "2026-07-01T11:54:42.489Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/f9/066794cca041b969964f779ee5fa66a9498bbf34248ac39c5d7954e4198f/pillow-12.3.0-cp313-cp313-win32.whl", hash = "sha256:a876864214e136f0eb367788dbd7df045f4806801518e2cfe9e13229cfe06d8f", size = 6473287, upload-time = "2026-07-01T11:54:44.9Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/9b/7a58e61d62be561da3a356fe2384d4059a6345fc130e23ef1c36a5b81d24/pillow-12.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:1cca606cd25738df4ed873d5ad46bbdb3d83b5cbca291f6b4ff13a4df6b0bbe8", size = 7239691, upload-time = "2026-07-01T11:54:47.141Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b0/c4ed4f0ef8f8fa5ee8351537db6650bb8189f7e118842978dd6589065692/pillow-12.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:b629de27fda84b42cde7edef0d85f13b958b47f6e9bbcbba9b673c562a89bd8b", size = 2568185, upload-time = "2026-07-01T11:54:49.137Z" },
+    { url = "https://files.pythonhosted.org/packages/75/18/2e8b40223153ccbc60df07f9e8928dc0c76202aa4e55ae9f53962b6510d6/pillow-12.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b3c777e849237620b022f7f297dd67705f9f5cf1685f09f02e46f93e92725468", size = 5302510, upload-time = "2026-07-01T11:56:25.736Z" },
+    { url = "https://files.pythonhosted.org/packages/46/3e/51fabf59d5ab801ceab709453d3ab6b180083496579549de4c45ced6528a/pillow-12.3.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:b343699e8308bdc51978310e1c959c584e7869cc8c40780058c87da7781a1e94", size = 4736058, upload-time = "2026-07-01T11:56:28.041Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/20/22fe9384b7949e25fb1293bcfc84fb82590ff4ea6b37c95b24d26d793d86/pillow-12.3.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbd139c8447d25dd750ab79ee274cc5e1fe80fc56340ab10b18a195e1b6eca3e", size = 5237776, upload-time = "2026-07-01T11:56:30.263Z" },
+    { url = "https://files.pythonhosted.org/packages/08/14/f6ba68107680ffa74b39985f3f30884e41318fbc4250caa423c79b4788bb/pillow-12.3.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e7e480451b9fa137494bccd3a7d69adbe8ac65a87d97be61e11f1b1050a5bac3", size = 5860358, upload-time = "2026-07-01T11:56:32.68Z" },
+    { url = "https://files.pythonhosted.org/packages/36/54/0169bc772ec491108b62f644f8ecf1fe5d8ae5ebafde2ee2142210166903/pillow-12.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:04f01d28a6aaff387bf842a13be313df23ba0597a44f1a976c9feb3c6ff4711a", size = 7231786, upload-time = "2026-07-01T11:56:35.046Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/61/33/9611380c2bdb1225fdef633e2a9610622310fed35ab11dac9620972ee088/platformdirs-4.5.0.tar.gz", hash = "sha256:70ddccdd7c99fc5942e9fc25636a8b34d04c24b335100223152c2803e4063312", size = 21632, upload-time = "2025-10-08T17:44:48.791Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/73/cb/ac7874b3e5d58441674fb70742e6c374b28b0c7cb988d37d991cde47166c/platformdirs-4.5.0-py3-none-any.whl", hash = "sha256:e578a81bb873cbb89a41fcc904c7ef523cc18284b7e3b3ccf06aca1403b7ebd3", size = 18651, upload-time = "2025-10-08T17:44:47.223Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pre-commit"
+version = "4.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cfgv" },
+    { name = "identify" },
+    { name = "nodeenv" },
+    { name = "pyyaml" },
+    { name = "virtualenv" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ff/29/7cf5bbc236333876e4b41f56e06857a87937ce4bf91e117a6991a2dbb02a/pre_commit-4.3.0.tar.gz", hash = "sha256:499fe450cc9d42e9d58e606262795ecb64dd05438943c62b66f6a8673da30b16", size = 193792, upload-time = "2025-08-09T18:56:14.651Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5b/a5/987a405322d78a73b66e39e4a90e4ef156fd7141bf71df987e50717c321b/pre_commit-4.3.0-py2.py3-none-any.whl", hash = "sha256:2b0747ad7e6e967169136edffee14c16e148a778a54e4f967921aa1ebf2308d8", size = 220965, upload-time = "2025-08-09T18:56:13.192Z" },
+]
+
+[[package]]
+name = "prettytable"
+version = "3.16.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wcwidth" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/99/b1/85e18ac92afd08c533603e3393977b6bc1443043115a47bb094f3b98f94f/prettytable-3.16.0.tar.gz", hash = "sha256:3c64b31719d961bf69c9a7e03d0c1e477320906a98da63952bc6698d6164ff57", size = 66276, upload-time = "2025-03-24T19:39:04.008Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/02/c7/5613524e606ea1688b3bdbf48aa64bafb6d0a4ac3750274c43b6158a390f/prettytable-3.16.0-py3-none-any.whl", hash = "sha256:b5eccfabb82222f5aa46b798ff02a8452cf530a352c31bddfa29be41242863aa", size = 33863, upload-time = "2025-03-24T19:39:02.359Z" },
+]
+
+[[package]]
+name = "prompt-toolkit"
+version = "3.0.52"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wcwidth" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" },
+]
+
+[[package]]
+name = "protobuf"
+version = "6.33.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", hash = "sha256:a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135", size = 444531, upload-time = "2026-03-18T19:05:00.988Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fc/9f/2f509339e89cfa6f6a4c4ff50438db9ca488dec341f7e454adad60150b00/protobuf-6.33.6-cp310-abi3-win32.whl", hash = "sha256:7d29d9b65f8afef196f8334e80d6bc1d5d4adedb449971fefd3723824e6e77d3", size = 425739, upload-time = "2026-03-18T19:04:48.373Z" },
+    { url = "https://files.pythonhosted.org/packages/76/5d/683efcd4798e0030c1bab27374fd13a89f7c2515fb1f3123efdfaa5eab57/protobuf-6.33.6-cp310-abi3-win_amd64.whl", hash = "sha256:0cd27b587afca21b7cfa59a74dcbd48a50f0a6400cfb59391340ad729d91d326", size = 437089, upload-time = "2026-03-18T19:04:50.381Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/01/a3c3ed5cd186f39e7880f8303cc51385a198a81469d53d0fdecf1f64d929/protobuf-6.33.6-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:9720e6961b251bde64edfdab7d500725a2af5280f3f4c87e57c0208376aa8c3a", size = 427737, upload-time = "2026-03-18T19:04:51.866Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/90/b3c01fdec7d2f627b3a6884243ba328c1217ed2d978def5c12dc50d328a3/protobuf-6.33.6-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:e2afbae9b8e1825e3529f88d514754e094278bb95eadc0e199751cdd9a2e82a2", size = 324610, upload-time = "2026-03-18T19:04:53.096Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/ca/25afc144934014700c52e05103c2421997482d561f3101ff352e1292fb81/protobuf-6.33.6-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:c96c37eec15086b79762ed265d59ab204dabc53056e3443e702d2681f4b39ce3", size = 339381, upload-time = "2026-03-18T19:04:54.616Z" },
+    { url = "https://files.pythonhosted.org/packages/16/92/d1e32e3e0d894fe00b15ce28ad4944ab692713f2e7f0a99787405e43533a/protobuf-6.33.6-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593", size = 323436, upload-time = "2026-03-18T19:04:55.768Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", hash = "sha256:77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901", size = 170656, upload-time = "2026-03-18T19:04:59.826Z" },
+]
+
+[[package]]
+name = "ptyprocess"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" },
+]
+
+[[package]]
+name = "pure-eval"
+version = "0.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" },
+]
+
+[[package]]
+name = "pybtex"
+version = "0.25.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "latexcodec" },
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5f/bc/c2be05ca72f8c103670e983df8be26d1e288bc6556f487fa8cccaa27779f/pybtex-0.25.1.tar.gz", hash = "sha256:9eaf90267c7e83e225af89fea65c370afbf65f458220d3946a9e3049e1eca491", size = 406157, upload-time = "2025-06-26T13:27:41.903Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/25/68/ceb5d6679baa326261f5d3e5113d9cfed6efef2810afd9f18bffb8ed312b/pybtex-0.25.1-py2.py3-none-any.whl", hash = "sha256:9053b0d619409a0a83f38abad5d9921de5f7b3ede00742beafcd9f10ad0d8c5c", size = 127437, upload-time = "2025-06-26T13:27:43.585Z" },
+]
+
+[[package]]
+name = "pybtex-docutils"
+version = "1.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "docutils" },
+    { name = "pybtex" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7e/84/796ea94d26188a853660f81bded39f8de4cfe595130aef0dea1088705a11/pybtex-docutils-1.0.3.tar.gz", hash = "sha256:3a7ebdf92b593e00e8c1c538aa9a20bca5d92d84231124715acc964d51d93c6b", size = 18348, upload-time = "2023-08-22T18:47:54.833Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/11/b1/ce1f4596211efb5410e178a803f08e59b20bedb66837dcf41e21c54f9ec1/pybtex_docutils-1.0.3-py3-none-any.whl", hash = "sha256:8fd290d2ae48e32fcb54d86b0efb8d573198653c7e2447d5bec5847095f430b9", size = 6385, upload-time = "2023-08-22T06:43:20.513Z" },
+]
+
+[[package]]
+name = "pycollada"
+version = "0.9.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/25/13/21debba42c0c255acba29f42af8785ecad656948d30fde5302d5e4494d1c/pycollada-0.9.2.tar.gz", hash = "sha256:7ca12267be0a2b93e495d6036e6b274023a9457ded641954eb0c470efe153d6e", size = 109972, upload-time = "2025-06-30T16:23:48.254Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/75/04e83be415fc67fa29d2447eb3248ea3bb79c2243be3f2fdfcca3699ce8b/pycollada-0.9.2-py3-none-any.whl", hash = "sha256:12fbeef6461688b6b3775c50196a2bb5f8813c0d39923a5a49681a75eb4622c9", size = 128399, upload-time = "2025-06-30T16:23:47.327Z" },
+]
+
+[[package]]
+name = "pycparser"
+version = "2.23"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734, upload-time = "2025-09-09T13:23:47.91Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140, upload-time = "2025-09-09T13:23:46.651Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/1e/4f0a3233767010308f2fd6bd0814597e3f63f1dc98304a9112b8759df4ff/pydantic-2.12.3.tar.gz", hash = "sha256:1da1c82b0fc140bb0103bc1441ffe062154c8d38491189751ee00fd8ca65ce74", size = 819383, upload-time = "2025-10-17T15:04:21.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a1/6b/83661fa77dcefa195ad5f8cd9af3d1a7450fd57cc883ad04d65446ac2029/pydantic-2.12.3-py3-none-any.whl", hash = "sha256:6986454a854bc3bc6e5443e1369e06a3a456af9d339eda45510f517d9ea5c6bf", size = 462431, upload-time = "2025-10-17T15:04:19.346Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/18/d0944e8eaaa3efd0a91b0f1fc537d3be55ad35091b6a87638211ba691964/pydantic_core-2.41.4.tar.gz", hash = "sha256:70e47929a9d4a1905a67e4b687d5946026390568a8e952b92824118063cee4d5", size = 457557, upload-time = "2025-10-14T10:23:47.909Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a7/3d/9b8ca77b0f76fcdbf8bc6b72474e264283f461284ca84ac3fde570c6c49a/pydantic_core-2.41.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2442d9a4d38f3411f22eb9dd0912b7cbf4b7d5b6c92c4173b75d3e1ccd84e36e", size = 2111197, upload-time = "2025-10-14T10:19:43.303Z" },
+    { url = "https://files.pythonhosted.org/packages/59/92/b7b0fe6ed4781642232755cb7e56a86e2041e1292f16d9ae410a0ccee5ac/pydantic_core-2.41.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:30a9876226dda131a741afeab2702e2d127209bde3c65a2b8133f428bc5d006b", size = 1917909, upload-time = "2025-10-14T10:19:45.194Z" },
+    { url = "https://files.pythonhosted.org/packages/52/8c/3eb872009274ffa4fb6a9585114e161aa1a0915af2896e2d441642929fe4/pydantic_core-2.41.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d55bbac04711e2980645af68b97d445cdbcce70e5216de444a6c4b6943ebcccd", size = 1969905, upload-time = "2025-10-14T10:19:46.567Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/21/35adf4a753bcfaea22d925214a0c5b880792e3244731b3f3e6fec0d124f7/pydantic_core-2.41.4-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e1d778fb7849a42d0ee5927ab0f7453bf9f85eef8887a546ec87db5ddb178945", size = 2051938, upload-time = "2025-10-14T10:19:48.237Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/d0/cdf7d126825e36d6e3f1eccf257da8954452934ede275a8f390eac775e89/pydantic_core-2.41.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1b65077a4693a98b90ec5ad8f203ad65802a1b9b6d4a7e48066925a7e1606706", size = 2250710, upload-time = "2025-10-14T10:19:49.619Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/1c/af1e6fd5ea596327308f9c8d1654e1285cc3d8de0d584a3c9d7705bf8a7c/pydantic_core-2.41.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:62637c769dee16eddb7686bf421be48dfc2fae93832c25e25bc7242e698361ba", size = 2367445, upload-time = "2025-10-14T10:19:51.269Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/81/8cece29a6ef1b3a92f956ea6da6250d5b2d2e7e4d513dd3b4f0c7a83dfea/pydantic_core-2.41.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2dfe3aa529c8f501babf6e502936b9e8d4698502b2cfab41e17a028d91b1ac7b", size = 2072875, upload-time = "2025-10-14T10:19:52.671Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/37/a6a579f5fc2cd4d5521284a0ab6a426cc6463a7b3897aeb95b12f1ba607b/pydantic_core-2.41.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ca2322da745bf2eeb581fc9ea3bbb31147702163ccbcbf12a3bb630e4bf05e1d", size = 2191329, upload-time = "2025-10-14T10:19:54.214Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/03/505020dc5c54ec75ecba9f41119fd1e48f9e41e4629942494c4a8734ded1/pydantic_core-2.41.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e8cd3577c796be7231dcf80badcf2e0835a46665eaafd8ace124d886bab4d700", size = 2151658, upload-time = "2025-10-14T10:19:55.843Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/5d/2c0d09fb53aa03bbd2a214d89ebfa6304be7df9ed86ee3dc7770257f41ee/pydantic_core-2.41.4-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:1cae8851e174c83633f0833e90636832857297900133705ee158cf79d40f03e6", size = 2316777, upload-time = "2025-10-14T10:19:57.607Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/4b/c2c9c8f5e1f9c864b57d08539d9d3db160e00491c9f5ee90e1bfd905e644/pydantic_core-2.41.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a26d950449aae348afe1ac8be5525a00ae4235309b729ad4d3399623125b43c9", size = 2320705, upload-time = "2025-10-14T10:19:59.016Z" },
+    { url = "https://files.pythonhosted.org/packages/28/c3/a74c1c37f49c0a02c89c7340fafc0ba816b29bd495d1a31ce1bdeacc6085/pydantic_core-2.41.4-cp310-cp310-win32.whl", hash = "sha256:0cf2a1f599efe57fa0051312774280ee0f650e11152325e41dfd3018ef2c1b57", size = 1975464, upload-time = "2025-10-14T10:20:00.581Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/23/5dd5c1324ba80303368f7569e2e2e1a721c7d9eb16acb7eb7b7f85cb1be2/pydantic_core-2.41.4-cp310-cp310-win_amd64.whl", hash = "sha256:a8c2e340d7e454dc3340d3d2e8f23558ebe78c98aa8f68851b04dcb7bc37abdc", size = 2024497, upload-time = "2025-10-14T10:20:03.018Z" },
+    { url = "https://files.pythonhosted.org/packages/62/4c/f6cbfa1e8efacd00b846764e8484fe173d25b8dab881e277a619177f3384/pydantic_core-2.41.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:28ff11666443a1a8cf2a044d6a545ebffa8382b5f7973f22c36109205e65dc80", size = 2109062, upload-time = "2025-10-14T10:20:04.486Z" },
+    { url = "https://files.pythonhosted.org/packages/21/f8/40b72d3868896bfcd410e1bd7e516e762d326201c48e5b4a06446f6cf9e8/pydantic_core-2.41.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:61760c3925d4633290292bad462e0f737b840508b4f722247d8729684f6539ae", size = 1916301, upload-time = "2025-10-14T10:20:06.857Z" },
+    { url = "https://files.pythonhosted.org/packages/94/4d/d203dce8bee7faeca791671c88519969d98d3b4e8f225da5b96dad226fc8/pydantic_core-2.41.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eae547b7315d055b0de2ec3965643b0ab82ad0106a7ffd29615ee9f266a02827", size = 1968728, upload-time = "2025-10-14T10:20:08.353Z" },
+    { url = "https://files.pythonhosted.org/packages/65/f5/6a66187775df87c24d526985b3a5d78d861580ca466fbd9d4d0e792fcf6c/pydantic_core-2.41.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ef9ee5471edd58d1fcce1c80ffc8783a650e3e3a193fe90d52e43bb4d87bff1f", size = 2050238, upload-time = "2025-10-14T10:20:09.766Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/b9/78336345de97298cf53236b2f271912ce11f32c1e59de25a374ce12f9cce/pydantic_core-2.41.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:15dd504af121caaf2c95cb90c0ebf71603c53de98305621b94da0f967e572def", size = 2249424, upload-time = "2025-10-14T10:20:11.732Z" },
+    { url = "https://files.pythonhosted.org/packages/99/bb/a4584888b70ee594c3d374a71af5075a68654d6c780369df269118af7402/pydantic_core-2.41.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3a926768ea49a8af4d36abd6a8968b8790f7f76dd7cbd5a4c180db2b4ac9a3a2", size = 2366047, upload-time = "2025-10-14T10:20:13.647Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/8d/17fc5de9d6418e4d2ae8c675f905cdafdc59d3bf3bf9c946b7ab796a992a/pydantic_core-2.41.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6916b9b7d134bff5440098a4deb80e4cb623e68974a87883299de9124126c2a8", size = 2071163, upload-time = "2025-10-14T10:20:15.307Z" },
+    { url = "https://files.pythonhosted.org/packages/54/e7/03d2c5c0b8ed37a4617430db68ec5e7dbba66358b629cd69e11b4d564367/pydantic_core-2.41.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5cf90535979089df02e6f17ffd076f07237efa55b7343d98760bde8743c4b265", size = 2190585, upload-time = "2025-10-14T10:20:17.3Z" },
+    { url = "https://files.pythonhosted.org/packages/be/fc/15d1c9fe5ad9266a5897d9b932b7f53d7e5cfc800573917a2c5d6eea56ec/pydantic_core-2.41.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:7533c76fa647fade2d7ec75ac5cc079ab3f34879626dae5689b27790a6cf5a5c", size = 2150109, upload-time = "2025-10-14T10:20:19.143Z" },
+    { url = "https://files.pythonhosted.org/packages/26/ef/e735dd008808226c83ba56972566138665b71477ad580fa5a21f0851df48/pydantic_core-2.41.4-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:37e516bca9264cbf29612539801ca3cd5d1be465f940417b002905e6ed79d38a", size = 2315078, upload-time = "2025-10-14T10:20:20.742Z" },
+    { url = "https://files.pythonhosted.org/packages/90/00/806efdcf35ff2ac0f938362350cd9827b8afb116cc814b6b75cf23738c7c/pydantic_core-2.41.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:0c19cb355224037c83642429b8ce261ae108e1c5fbf5c028bac63c77b0f8646e", size = 2318737, upload-time = "2025-10-14T10:20:22.306Z" },
+    { url = "https://files.pythonhosted.org/packages/41/7e/6ac90673fe6cb36621a2283552897838c020db343fa86e513d3f563b196f/pydantic_core-2.41.4-cp311-cp311-win32.whl", hash = "sha256:09c2a60e55b357284b5f31f5ab275ba9f7f70b7525e18a132ec1f9160b4f1f03", size = 1974160, upload-time = "2025-10-14T10:20:23.817Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/9d/7c5e24ee585c1f8b6356e1d11d40ab807ffde44d2db3b7dfd6d20b09720e/pydantic_core-2.41.4-cp311-cp311-win_amd64.whl", hash = "sha256:711156b6afb5cb1cb7c14a2cc2c4a8b4c717b69046f13c6b332d8a0a8f41ca3e", size = 2021883, upload-time = "2025-10-14T10:20:25.48Z" },
+    { url = "https://files.pythonhosted.org/packages/33/90/5c172357460fc28b2871eb4a0fb3843b136b429c6fa827e4b588877bf115/pydantic_core-2.41.4-cp311-cp311-win_arm64.whl", hash = "sha256:6cb9cf7e761f4f8a8589a45e49ed3c0d92d1d696a45a6feaee8c904b26efc2db", size = 1968026, upload-time = "2025-10-14T10:20:27.039Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/81/d3b3e95929c4369d30b2a66a91db63c8ed0a98381ae55a45da2cd1cc1288/pydantic_core-2.41.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:ab06d77e053d660a6faaf04894446df7b0a7e7aba70c2797465a0a1af00fc887", size = 2099043, upload-time = "2025-10-14T10:20:28.561Z" },
+    { url = "https://files.pythonhosted.org/packages/58/da/46fdac49e6717e3a94fc9201403e08d9d61aa7a770fab6190b8740749047/pydantic_core-2.41.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c53ff33e603a9c1179a9364b0a24694f183717b2e0da2b5ad43c316c956901b2", size = 1910699, upload-time = "2025-10-14T10:20:30.217Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/63/4d948f1b9dd8e991a5a98b77dd66c74641f5f2e5225fee37994b2e07d391/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:304c54176af2c143bd181d82e77c15c41cbacea8872a2225dd37e6544dce9999", size = 1952121, upload-time = "2025-10-14T10:20:32.246Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/a7/e5fc60a6f781fc634ecaa9ecc3c20171d238794cef69ae0af79ac11b89d7/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:025ba34a4cf4fb32f917d5d188ab5e702223d3ba603be4d8aca2f82bede432a4", size = 2041590, upload-time = "2025-10-14T10:20:34.332Z" },
+    { url = "https://files.pythonhosted.org/packages/70/69/dce747b1d21d59e85af433428978a1893c6f8a7068fa2bb4a927fba7a5ff/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b9f5f30c402ed58f90c70e12eff65547d3ab74685ffe8283c719e6bead8ef53f", size = 2219869, upload-time = "2025-10-14T10:20:35.965Z" },
+    { url = "https://files.pythonhosted.org/packages/83/6a/c070e30e295403bf29c4df1cb781317b6a9bac7cd07b8d3acc94d501a63c/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dd96e5d15385d301733113bcaa324c8bcf111275b7675a9c6e88bfb19fc05e3b", size = 2345169, upload-time = "2025-10-14T10:20:37.627Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/83/06d001f8043c336baea7fd202a9ac7ad71f87e1c55d8112c50b745c40324/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98f348cbb44fae6e9653c1055db7e29de67ea6a9ca03a5fa2c2e11a47cff0e47", size = 2070165, upload-time = "2025-10-14T10:20:39.246Z" },
+    { url = "https://files.pythonhosted.org/packages/14/0a/e567c2883588dd12bcbc110232d892cf385356f7c8a9910311ac997ab715/pydantic_core-2.41.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ec22626a2d14620a83ca583c6f5a4080fa3155282718b6055c2ea48d3ef35970", size = 2189067, upload-time = "2025-10-14T10:20:41.015Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/1d/3d9fca34273ba03c9b1c5289f7618bc4bd09c3ad2289b5420481aa051a99/pydantic_core-2.41.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:3a95d4590b1f1a43bf33ca6d647b990a88f4a3824a8c4572c708f0b45a5290ed", size = 2132997, upload-time = "2025-10-14T10:20:43.106Z" },
+    { url = "https://files.pythonhosted.org/packages/52/70/d702ef7a6cd41a8afc61f3554922b3ed8d19dd54c3bd4bdbfe332e610827/pydantic_core-2.41.4-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:f9672ab4d398e1b602feadcffcdd3af44d5f5e6ddc15bc7d15d376d47e8e19f8", size = 2307187, upload-time = "2025-10-14T10:20:44.849Z" },
+    { url = "https://files.pythonhosted.org/packages/68/4c/c06be6e27545d08b802127914156f38d10ca287a9e8489342793de8aae3c/pydantic_core-2.41.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:84d8854db5f55fead3b579f04bda9a36461dab0730c5d570e1526483e7bb8431", size = 2305204, upload-time = "2025-10-14T10:20:46.781Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/e5/35ae4919bcd9f18603419e23c5eaf32750224a89d41a8df1a3704b69f77e/pydantic_core-2.41.4-cp312-cp312-win32.whl", hash = "sha256:9be1c01adb2ecc4e464392c36d17f97e9110fbbc906bcbe1c943b5b87a74aabd", size = 1972536, upload-time = "2025-10-14T10:20:48.39Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/c2/49c5bb6d2a49eb2ee3647a93e3dae7080c6409a8a7558b075027644e879c/pydantic_core-2.41.4-cp312-cp312-win_amd64.whl", hash = "sha256:d682cf1d22bab22a5be08539dca3d1593488a99998f9f412137bc323179067ff", size = 2031132, upload-time = "2025-10-14T10:20:50.421Z" },
+    { url = "https://files.pythonhosted.org/packages/06/23/936343dbcba6eec93f73e95eb346810fc732f71ba27967b287b66f7b7097/pydantic_core-2.41.4-cp312-cp312-win_arm64.whl", hash = "sha256:833eebfd75a26d17470b58768c1834dfc90141b7afc6eb0429c21fc5a21dcfb8", size = 1969483, upload-time = "2025-10-14T10:20:52.35Z" },
+    { url = "https://files.pythonhosted.org/packages/13/d0/c20adabd181a029a970738dfe23710b52a31f1258f591874fcdec7359845/pydantic_core-2.41.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:85e050ad9e5f6fe1004eec65c914332e52f429bc0ae12d6fa2092407a462c746", size = 2105688, upload-time = "2025-10-14T10:20:54.448Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b6/0ce5c03cec5ae94cca220dfecddc453c077d71363b98a4bbdb3c0b22c783/pydantic_core-2.41.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7393f1d64792763a48924ba31d1e44c2cfbc05e3b1c2c9abb4ceeadd912cced", size = 1910807, upload-time = "2025-10-14T10:20:56.115Z" },
+    { url = "https://files.pythonhosted.org/packages/68/3e/800d3d02c8beb0b5c069c870cbb83799d085debf43499c897bb4b4aaff0d/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94dab0940b0d1fb28bcab847adf887c66a27a40291eedf0b473be58761c9799a", size = 1956669, upload-time = "2025-10-14T10:20:57.874Z" },
+    { url = "https://files.pythonhosted.org/packages/60/a4/24271cc71a17f64589be49ab8bd0751f6a0a03046c690df60989f2f95c2c/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:de7c42f897e689ee6f9e93c4bec72b99ae3b32a2ade1c7e4798e690ff5246e02", size = 2051629, upload-time = "2025-10-14T10:21:00.006Z" },
+    { url = "https://files.pythonhosted.org/packages/68/de/45af3ca2f175d91b96bfb62e1f2d2f1f9f3b14a734afe0bfeff079f78181/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:664b3199193262277b8b3cd1e754fb07f2c6023289c815a1e1e8fb415cb247b1", size = 2224049, upload-time = "2025-10-14T10:21:01.801Z" },
+    { url = "https://files.pythonhosted.org/packages/af/8f/ae4e1ff84672bf869d0a77af24fd78387850e9497753c432875066b5d622/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d95b253b88f7d308b1c0b417c4624f44553ba4762816f94e6986819b9c273fb2", size = 2342409, upload-time = "2025-10-14T10:21:03.556Z" },
+    { url = "https://files.pythonhosted.org/packages/18/62/273dd70b0026a085c7b74b000394e1ef95719ea579c76ea2f0cc8893736d/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a1351f5bbdbbabc689727cb91649a00cb9ee7203e0a6e54e9f5ba9e22e384b84", size = 2069635, upload-time = "2025-10-14T10:21:05.385Z" },
+    { url = "https://files.pythonhosted.org/packages/30/03/cf485fff699b4cdaea469bc481719d3e49f023241b4abb656f8d422189fc/pydantic_core-2.41.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1affa4798520b148d7182da0615d648e752de4ab1a9566b7471bc803d88a062d", size = 2194284, upload-time = "2025-10-14T10:21:07.122Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/7e/c8e713db32405dfd97211f2fc0a15d6bf8adb7640f3d18544c1f39526619/pydantic_core-2.41.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7b74e18052fea4aa8dea2fb7dbc23d15439695da6cbe6cfc1b694af1115df09d", size = 2137566, upload-time = "2025-10-14T10:21:08.981Z" },
+    { url = "https://files.pythonhosted.org/packages/04/f7/db71fd4cdccc8b75990f79ccafbbd66757e19f6d5ee724a6252414483fb4/pydantic_core-2.41.4-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:285b643d75c0e30abda9dc1077395624f314a37e3c09ca402d4015ef5979f1a2", size = 2316809, upload-time = "2025-10-14T10:21:10.805Z" },
+    { url = "https://files.pythonhosted.org/packages/76/63/a54973ddb945f1bca56742b48b144d85c9fc22f819ddeb9f861c249d5464/pydantic_core-2.41.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:f52679ff4218d713b3b33f88c89ccbf3a5c2c12ba665fb80ccc4192b4608dbab", size = 2311119, upload-time = "2025-10-14T10:21:12.583Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/03/5d12891e93c19218af74843a27e32b94922195ded2386f7b55382f904d2f/pydantic_core-2.41.4-cp313-cp313-win32.whl", hash = "sha256:ecde6dedd6fff127c273c76821bb754d793be1024bc33314a120f83a3c69460c", size = 1981398, upload-time = "2025-10-14T10:21:14.584Z" },
+    { url = "https://files.pythonhosted.org/packages/be/d8/fd0de71f39db91135b7a26996160de71c073d8635edfce8b3c3681be0d6d/pydantic_core-2.41.4-cp313-cp313-win_amd64.whl", hash = "sha256:d081a1f3800f05409ed868ebb2d74ac39dd0c1ff6c035b5162356d76030736d4", size = 2030735, upload-time = "2025-10-14T10:21:16.432Z" },
+    { url = "https://files.pythonhosted.org/packages/72/86/c99921c1cf6650023c08bfab6fe2d7057a5142628ef7ccfa9921f2dda1d5/pydantic_core-2.41.4-cp313-cp313-win_arm64.whl", hash = "sha256:f8e49c9c364a7edcbe2a310f12733aad95b022495ef2a8d653f645e5d20c1564", size = 1973209, upload-time = "2025-10-14T10:21:18.213Z" },
+    { url = "https://files.pythonhosted.org/packages/36/0d/b5706cacb70a8414396efdda3d72ae0542e050b591119e458e2490baf035/pydantic_core-2.41.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:ed97fd56a561f5eb5706cebe94f1ad7c13b84d98312a05546f2ad036bafe87f4", size = 1877324, upload-time = "2025-10-14T10:21:20.363Z" },
+    { url = "https://files.pythonhosted.org/packages/de/2d/cba1fa02cfdea72dfb3a9babb067c83b9dff0bbcb198368e000a6b756ea7/pydantic_core-2.41.4-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a870c307bf1ee91fc58a9a61338ff780d01bfae45922624816878dce784095d2", size = 1884515, upload-time = "2025-10-14T10:21:22.339Z" },
+    { url = "https://files.pythonhosted.org/packages/07/ea/3df927c4384ed9b503c9cc2d076cf983b4f2adb0c754578dfb1245c51e46/pydantic_core-2.41.4-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d25e97bc1f5f8f7985bdc2335ef9e73843bb561eb1fa6831fdfc295c1c2061cf", size = 2042819, upload-time = "2025-10-14T10:21:26.683Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/ee/df8e871f07074250270a3b1b82aad4cd0026b588acd5d7d3eb2fcb1471a3/pydantic_core-2.41.4-cp313-cp313t-win_amd64.whl", hash = "sha256:d405d14bea042f166512add3091c1af40437c2e7f86988f3915fabd27b1e9cd2", size = 1995866, upload-time = "2025-10-14T10:21:28.951Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/de/b20f4ab954d6d399499c33ec4fafc46d9551e11dc1858fb7f5dca0748ceb/pydantic_core-2.41.4-cp313-cp313t-win_arm64.whl", hash = "sha256:19f3684868309db5263a11bace3c45d93f6f24afa2ffe75a647583df22a2ff89", size = 1970034, upload-time = "2025-10-14T10:21:30.869Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/12/5ba58daa7f453454464f92b3ca7b9d7c657d8641c48e370c3ebc9a82dd78/pydantic_core-2.41.4-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:a1b2cfec3879afb742a7b0bcfa53e4f22ba96571c9e54d6a3afe1052d17d843b", size = 2122139, upload-time = "2025-10-14T10:22:47.288Z" },
+    { url = "https://files.pythonhosted.org/packages/21/fb/6860126a77725c3108baecd10fd3d75fec25191d6381b6eb2ac660228eac/pydantic_core-2.41.4-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:d175600d975b7c244af6eb9c9041f10059f20b8bbffec9e33fdd5ee3f67cdc42", size = 1936674, upload-time = "2025-10-14T10:22:49.555Z" },
+    { url = "https://files.pythonhosted.org/packages/de/be/57dcaa3ed595d81f8757e2b44a38240ac5d37628bce25fb20d02c7018776/pydantic_core-2.41.4-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0f184d657fa4947ae5ec9c47bd7e917730fa1cbb78195037e32dcbab50aca5ee", size = 1956398, upload-time = "2025-10-14T10:22:52.19Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/1d/679a344fadb9695f1a6a294d739fbd21d71fa023286daeea8c0ed49e7c2b/pydantic_core-2.41.4-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ed810568aeffed3edc78910af32af911c835cc39ebbfacd1f0ab5dd53028e5c", size = 2138674, upload-time = "2025-10-14T10:22:54.499Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/48/ae937e5a831b7c0dc646b2ef788c27cd003894882415300ed21927c21efa/pydantic_core-2.41.4-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:4f5d640aeebb438517150fdeec097739614421900e4a08db4a3ef38898798537", size = 2112087, upload-time = "2025-10-14T10:22:56.818Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/db/6db8073e3d32dae017da7e0d16a9ecb897d0a4d92e00634916e486097961/pydantic_core-2.41.4-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:4a9ab037b71927babc6d9e7fc01aea9e66dc2a4a34dff06ef0724a4049629f94", size = 1920387, upload-time = "2025-10-14T10:22:59.342Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/c1/dd3542d072fcc336030d66834872f0328727e3b8de289c662faa04aa270e/pydantic_core-2.41.4-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4dab9484ec605c3016df9ad4fd4f9a390bc5d816a3b10c6550f8424bb80b18c", size = 1951495, upload-time = "2025-10-14T10:23:02.089Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/c6/db8d13a1f8ab3f1eb08c88bd00fd62d44311e3456d1e85c0e59e0a0376e7/pydantic_core-2.41.4-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bd8a5028425820731d8c6c098ab642d7b8b999758e24acae03ed38a66eca8335", size = 2139008, upload-time = "2025-10-14T10:23:04.539Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/d4/912e976a2dd0b49f31c98a060ca90b353f3b73ee3ea2fd0030412f6ac5ec/pydantic_core-2.41.4-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:1e5ab4fc177dd41536b3c32b2ea11380dd3d4619a385860621478ac2d25ceb00", size = 2106739, upload-time = "2025-10-14T10:23:06.934Z" },
+    { url = "https://files.pythonhosted.org/packages/71/f0/66ec5a626c81eba326072d6ee2b127f8c139543f1bf609b4842978d37833/pydantic_core-2.41.4-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:3d88d0054d3fa11ce936184896bed3c1c5441d6fa483b498fac6a5d0dd6f64a9", size = 1932549, upload-time = "2025-10-14T10:23:09.24Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/af/625626278ca801ea0a658c2dcf290dc9f21bb383098e99e7c6a029fccfc0/pydantic_core-2.41.4-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7b2a054a8725f05b4b6503357e0ac1c4e8234ad3b0c2ac130d6ffc66f0e170e2", size = 2135093, upload-time = "2025-10-14T10:23:11.626Z" },
+    { url = "https://files.pythonhosted.org/packages/20/f6/2fba049f54e0f4975fef66be654c597a1d005320fa141863699180c7697d/pydantic_core-2.41.4-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b0d9db5a161c99375a0c68c058e227bee1d89303300802601d76a3d01f74e258", size = 2187971, upload-time = "2025-10-14T10:23:14.437Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/80/65ab839a2dfcd3b949202f9d920c34f9de5a537c3646662bdf2f7d999680/pydantic_core-2.41.4-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:6273ea2c8ffdac7b7fda2653c49682db815aebf4a89243a6feccf5e36c18c347", size = 2147939, upload-time = "2025-10-14T10:23:16.831Z" },
+    { url = "https://files.pythonhosted.org/packages/44/58/627565d3d182ce6dfda18b8e1c841eede3629d59c9d7cbc1e12a03aeb328/pydantic_core-2.41.4-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:4c973add636efc61de22530b2ef83a65f39b6d6f656df97f678720e20de26caa", size = 2311400, upload-time = "2025-10-14T10:23:19.234Z" },
+    { url = "https://files.pythonhosted.org/packages/24/06/8a84711162ad5a5f19a88cead37cca81b4b1f294f46260ef7334ae4f24d3/pydantic_core-2.41.4-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:b69d1973354758007f46cf2d44a4f3d0933f10b6dc9bf15cf1356e037f6f731a", size = 2316840, upload-time = "2025-10-14T10:23:21.738Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/8b/b7bb512a4682a2f7fbfae152a755d37351743900226d29bd953aaf870eaa/pydantic_core-2.41.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:3619320641fd212aaf5997b6ca505e97540b7e16418f4a241f44cdf108ffb50d", size = 2149135, upload-time = "2025-10-14T10:23:24.379Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/7d/138e902ed6399b866f7cfe4435d22445e16fff888a1c00560d9dc79a780f/pydantic_core-2.41.4-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:491535d45cd7ad7e4a2af4a5169b0d07bebf1adfd164b0368da8aa41e19907a5", size = 2104721, upload-time = "2025-10-14T10:23:26.906Z" },
+    { url = "https://files.pythonhosted.org/packages/47/13/0525623cf94627f7b53b4c2034c81edc8491cbfc7c28d5447fa318791479/pydantic_core-2.41.4-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:54d86c0cada6aba4ec4c047d0e348cbad7063b87ae0f005d9f8c9ad04d4a92a2", size = 1931608, upload-time = "2025-10-14T10:23:29.306Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f9/744bc98137d6ef0a233f808bfc9b18cf94624bf30836a18d3b05d08bf418/pydantic_core-2.41.4-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eca1124aced216b2500dc2609eade086d718e8249cb9696660ab447d50a758bd", size = 2132986, upload-time = "2025-10-14T10:23:32.057Z" },
+    { url = "https://files.pythonhosted.org/packages/17/c8/629e88920171173f6049386cc71f893dff03209a9ef32b4d2f7e7c264bcf/pydantic_core-2.41.4-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6c9024169becccf0cb470ada03ee578d7348c119a0d42af3dcf9eda96e3a247c", size = 2187516, upload-time = "2025-10-14T10:23:34.871Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/0f/4f2734688d98488782218ca61bcc118329bf5de05bb7fe3adc7dd79b0b86/pydantic_core-2.41.4-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:26895a4268ae5a2849269f4991cdc97236e4b9c010e51137becf25182daac405", size = 2146146, upload-time = "2025-10-14T10:23:37.342Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/f2/ab385dbd94a052c62224b99cf99002eee99dbec40e10006c78575aead256/pydantic_core-2.41.4-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:ca4df25762cf71308c446e33c9b1fdca2923a3f13de616e2a949f38bf21ff5a8", size = 2311296, upload-time = "2025-10-14T10:23:40.145Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/8e/e4f12afe1beeb9823bba5375f8f258df0cc61b056b0195fb1cf9f62a1a58/pydantic_core-2.41.4-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:5a28fcedd762349519276c36634e71853b4541079cab4acaaac60c4421827308", size = 2315386, upload-time = "2025-10-14T10:23:42.624Z" },
+    { url = "https://files.pythonhosted.org/packages/48/f7/925f65d930802e3ea2eb4d5afa4cb8730c8dc0d2cb89a59dc4ed2fcb2d74/pydantic_core-2.41.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c173ddcd86afd2535e2b695217e82191580663a1d1928239f877f5a1649ef39f", size = 2147775, upload-time = "2025-10-14T10:23:45.406Z" },
+]
+
+[[package]]
+name = "pydata-sphinx-theme"
+version = "0.15.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "accessible-pygments" },
+    { name = "babel" },
+    { name = "beautifulsoup4" },
+    { name = "docutils" },
+    { name = "packaging" },
+    { name = "pygments" },
+    { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/67/ea/3ab478cccacc2e8ef69892c42c44ae547bae089f356c4b47caf61730958d/pydata_sphinx_theme-0.15.4.tar.gz", hash = "sha256:7762ec0ac59df3acecf49fd2f889e1b4565dbce8b88b2e29ee06fdd90645a06d", size = 2400673, upload-time = "2024-06-25T19:28:45.041Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/d3/c622950d87a2ffd1654208733b5bd1c5645930014abed8f4c0d74863988b/pydata_sphinx_theme-0.15.4-py3-none-any.whl", hash = "sha256:2136ad0e9500d0949f96167e63f3e298620040aea8f9c74621959eda5d4cf8e6", size = 4640157, upload-time = "2024-06-25T19:28:42.383Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pynacl"
+version = "1.6.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d9/9a/4019b524b03a13438637b11538c82781a5eda427394380381af8f04f467a/pynacl-1.6.2.tar.gz", hash = "sha256:018494d6d696ae03c7e656e5e74cdfd8ea1326962cc401bcf018f1ed8436811c", size = 3511692, upload-time = "2026-01-01T17:48:10.851Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/be/7b/4845bbf88e94586ec47a432da4e9107e3fc3ce37eb412b1398630a37f7dd/pynacl-1.6.2-cp38-abi3-macosx_10_10_universal2.whl", hash = "sha256:c949ea47e4206af7c8f604b8278093b674f7c79ed0d4719cc836902bf4517465", size = 388458, upload-time = "2026-01-01T17:32:16.829Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/b4/e927e0653ba63b02a4ca5b4d852a8d1d678afbf69b3dbf9c4d0785ac905c/pynacl-1.6.2-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8845c0631c0be43abdd865511c41eab235e0be69c81dc66a50911594198679b0", size = 800020, upload-time = "2026-01-01T17:32:18.34Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/81/d60984052df5c97b1d24365bc1e30024379b42c4edcd79d2436b1b9806f2/pynacl-1.6.2-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:22de65bb9010a725b0dac248f353bb072969c94fa8d6b1f34b87d7953cf7bbe4", size = 1399174, upload-time = "2026-01-01T17:32:20.239Z" },
+    { url = "https://files.pythonhosted.org/packages/68/f7/322f2f9915c4ef27d140101dd0ed26b479f7e6f5f183590fd32dfc48c4d3/pynacl-1.6.2-cp38-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:46065496ab748469cdd999246d17e301b2c24ae2fdf739132e580a0e94c94a87", size = 835085, upload-time = "2026-01-01T17:32:22.24Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d0/f301f83ac8dbe53442c5a43f6a39016f94f754d7a9815a875b65e218a307/pynacl-1.6.2-cp38-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a66d6fb6ae7661c58995f9c6435bda2b1e68b54b598a6a10247bfcdadac996c", size = 1437614, upload-time = "2026-01-01T17:32:23.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/58/fc6e649762b029315325ace1a8c6be66125e42f67416d3dbd47b69563d61/pynacl-1.6.2-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:26bfcd00dcf2cf160f122186af731ae30ab120c18e8375684ec2670dccd28130", size = 818251, upload-time = "2026-01-01T17:32:25.69Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/a8/b917096b1accc9acd878819a49d3d84875731a41eb665f6ebc826b1af99e/pynacl-1.6.2-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:c8a231e36ec2cab018c4ad4358c386e36eede0319a0c41fed24f840b1dac59f6", size = 1402859, upload-time = "2026-01-01T17:32:27.215Z" },
+    { url = "https://files.pythonhosted.org/packages/85/42/fe60b5f4473e12c72f977548e4028156f4d340b884c635ec6b063fe7e9a5/pynacl-1.6.2-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:68be3a09455743ff9505491220b64440ced8973fe930f270c8e07ccfa25b1f9e", size = 791926, upload-time = "2026-01-01T17:32:29.314Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f9/e40e318c604259301cc091a2a63f237d9e7b424c4851cafaea4ea7c4834e/pynacl-1.6.2-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8b097553b380236d51ed11356c953bf8ce36a29a3e596e934ecabe76c985a577", size = 1363101, upload-time = "2026-01-01T17:32:31.263Z" },
+    { url = "https://files.pythonhosted.org/packages/48/47/e761c254f410c023a469284a9bc210933e18588ca87706ae93002c05114c/pynacl-1.6.2-cp38-abi3-win32.whl", hash = "sha256:5811c72b473b2f38f7e2a3dc4f8642e3a3e9b5e7317266e4ced1fba85cae41aa", size = 227421, upload-time = "2026-01-01T17:32:33.076Z" },
+    { url = "https://files.pythonhosted.org/packages/41/ad/334600e8cacc7d86587fe5f565480fde569dfb487389c8e1be56ac21d8ac/pynacl-1.6.2-cp38-abi3-win_amd64.whl", hash = "sha256:62985f233210dee6548c223301b6c25440852e13d59a8b81490203c3227c5ba0", size = 239754, upload-time = "2026-01-01T17:32:34.557Z" },
+    { url = "https://files.pythonhosted.org/packages/29/7d/5945b5af29534641820d3bd7b00962abbbdfee84ec7e19f0d5b3175f9a31/pynacl-1.6.2-cp38-abi3-win_arm64.whl", hash = "sha256:834a43af110f743a754448463e8fd61259cd4ab5bbedcf70f9dabad1d28a394c", size = 184801, upload-time = "2026-01-01T17:32:36.309Z" },
+]
+
+[[package]]
+name = "pyopengl"
+version = "3.1.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/16/912b7225d56284859cd9a672827f18be43f8012f8b7b932bc4bd959a298e/pyopengl-3.1.10.tar.gz", hash = "sha256:c4a02d6866b54eb119c8e9b3fb04fa835a95ab802dd96607ab4cdb0012df8335", size = 1915580, upload-time = "2025-08-18T02:33:01.76Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/e4/1ba6f44e491c4eece978685230dde56b14d51a0365bc1b774ddaa94d14cd/pyopengl-3.1.10-py3-none-any.whl", hash = "sha256:794a943daced39300879e4e47bd94525280685f42dbb5a998d336cfff151d74f", size = 3194996, upload-time = "2025-08-18T02:32:59.902Z" },
+]
+
+[[package]]
+name = "pyparsing"
+version = "3.3.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" },
+]
+
+[[package]]
+name = "pyright"
+version = "1.1.408"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nodeenv" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/74/b2/5db700e52554b8f025faa9c3c624c59f1f6c8841ba81ab97641b54322f16/pyright-1.1.408.tar.gz", hash = "sha256:f28f2321f96852fa50b5829ea492f6adb0e6954568d1caa3f3af3a5f555eb684", size = 4400578, upload-time = "2026-01-08T08:07:38.795Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/82/a2c93e32800940d9573fb28c346772a14778b84ba7524e691b324620ab89/pyright-1.1.408-py3-none-any.whl", hash = "sha256:090b32865f4fdb1e0e6cd82bf5618480d48eecd2eb2e70f960982a3d9a4c17c1", size = 6399144, upload-time = "2026-01-08T08:07:37.082Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+    { name = "tomli", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
+]
+
+[[package]]
+name = "python-discovery"
+version = "1.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "filelock" },
+    { name = "platformdirs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b9/88/815e53084c5079a59df912825a279f41dd2e0df82281770eadc732f5352c/python_discovery-1.2.1.tar.gz", hash = "sha256:180c4d114bff1c32462537eac5d6a332b768242b76b69c0259c7d14b1b680c9e", size = 58457, upload-time = "2026-03-26T22:30:44.496Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/67/0f/019d3949a40280f6193b62bc010177d4ce702d0fce424322286488569cd3/python_discovery-1.2.1-py3-none-any.whl", hash = "sha256:b6a957b24c1cd79252484d3566d1b49527581d46e789aaf43181005e56201502", size = 31674, upload-time = "2026-03-26T22:30:43.396Z" },
+]
+
+[[package]]
+name = "pyvers"
+version = "0.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "packaging" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7f/39/c5432f541e6ea1d616dfd6ef42ce02792f7eb42dd44f5ed4439dbe17a58b/pyvers-0.1.0-py3-none-any.whl", hash = "sha256:065249805ae537ddf9a2d1a8dffc6d0a12474a347d2eaa2f35ebdae92c0c8199", size = 10092, upload-time = "2025-06-08T23:46:46.219Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" },
+    { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" },
+    { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+]
+
+[[package]]
+name = "referencing"
+version = "0.37.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "rpds-py" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.33.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", hash = "sha256:18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517", size = 134120, upload-time = "2026-03-30T16:09:15.531Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", hash = "sha256:4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a", size = 64947, upload-time = "2026-03-30T16:09:13.83Z" },
+]
+
+[[package]]
+name = "rich"
+version = "14.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fb/d2/8920e102050a0de7bfabeb4c4614a49248cf8d5d7a8d01885fbb24dc767a/rich-14.2.0.tar.gz", hash = "sha256:73ff50c7c0c1c77c8243079283f4edb376f0f6442433aecb8ce7e6d0b92d1fe4", size = 219990, upload-time = "2025-10-09T14:16:53.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/25/7a/b0178788f8dc6cafce37a212c99565fa1fe7872c70c6c9c1e1a372d9d88f/rich-14.2.0-py3-none-any.whl", hash = "sha256:76bc51fe2e57d2b1be1f96c524b890b816e334ab4c1e45888799bfaab0021edd", size = 243393, upload-time = "2025-10-09T14:16:51.245Z" },
+]
+
+[[package]]
+name = "roman-numerals"
+version = "4.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ae/f9/41dc953bbeb056c17d5f7a519f50fdf010bd0553be2d630bc69d1e022703/roman_numerals-4.1.0.tar.gz", hash = "sha256:1af8b147eb1405d5839e78aeb93131690495fe9da5c91856cb33ad55a7f1e5b2", size = 9077, upload-time = "2025-12-17T18:25:34.381Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/54/6f679c435d28e0a568d8e8a7c0a93a09010818634c3c3907fc98d8983770/roman_numerals-4.1.0-py3-none-any.whl", hash = "sha256:647ba99caddc2cc1e55a51e4360689115551bf4476d90e8162cf8c345fe233c7", size = 7676, upload-time = "2025-12-17T18:25:33.098Z" },
+]
+
+[[package]]
+name = "roman-numerals-py"
+version = "4.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "roman-numerals", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/b5/de96fca640f4f656eb79bbee0e79aeec52e3e0e359f8a3e6a0d366378b64/roman_numerals_py-4.1.0.tar.gz", hash = "sha256:f5d7b2b4ca52dd855ef7ab8eb3590f428c0b1ea480736ce32b01fef2a5f8daf9", size = 4274, upload-time = "2025-12-17T18:25:41.153Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/27/2c/daca29684cbe9fd4bc711f8246da3c10adca1ccc4d24436b17572eb2590e/roman_numerals_py-4.1.0-py3-none-any.whl", hash = "sha256:553114c1167141c1283a51743759723ecd05604a1b6b507225e91dc1a6df0780", size = 4547, upload-time = "2025-12-17T18:25:40.136Z" },
+]
+
+[[package]]
+name = "rpds-py"
+version = "0.27.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e9/dd/2c0cbe774744272b0ae725f44032c77bdcab6e8bcf544bffa3b6e70c8dba/rpds_py-0.27.1.tar.gz", hash = "sha256:26a1c73171d10b7acccbded82bf6a586ab8203601e565badc74bbbf8bc5a10f8", size = 27479, upload-time = "2025-08-27T12:16:36.024Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a5/ed/3aef893e2dd30e77e35d20d4ddb45ca459db59cead748cad9796ad479411/rpds_py-0.27.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:68afeec26d42ab3b47e541b272166a0b4400313946871cba3ed3a4fc0cab1cef", size = 371606, upload-time = "2025-08-27T12:12:25.189Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/82/9818b443e5d3eb4c83c3994561387f116aae9833b35c484474769c4a8faf/rpds_py-0.27.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:74e5b2f7bb6fa38b1b10546d27acbacf2a022a8b5543efb06cfebc72a59c85be", size = 353452, upload-time = "2025-08-27T12:12:27.433Z" },
+    { url = "https://files.pythonhosted.org/packages/99/c7/d2a110ffaaa397fc6793a83c7bd3545d9ab22658b7cdff05a24a4535cc45/rpds_py-0.27.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9024de74731df54546fab0bfbcdb49fae19159ecaecfc8f37c18d2c7e2c0bd61", size = 381519, upload-time = "2025-08-27T12:12:28.719Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/bc/e89581d1f9d1be7d0247eaef602566869fdc0d084008ba139e27e775366c/rpds_py-0.27.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:31d3ebadefcd73b73928ed0b2fd696f7fefda8629229f81929ac9c1854d0cffb", size = 394424, upload-time = "2025-08-27T12:12:30.207Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/2e/36a6861f797530e74bb6ed53495f8741f1ef95939eed01d761e73d559067/rpds_py-0.27.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b2e7f8f169d775dd9092a1743768d771f1d1300453ddfe6325ae3ab5332b4657", size = 523467, upload-time = "2025-08-27T12:12:31.808Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/59/c1bc2be32564fa499f988f0a5c6505c2f4746ef96e58e4d7de5cf923d77e/rpds_py-0.27.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d905d16f77eb6ab2e324e09bfa277b4c8e5e6b8a78a3e7ff8f3cdf773b4c013", size = 402660, upload-time = "2025-08-27T12:12:33.444Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/ec/ef8bf895f0628dd0a59e54d81caed6891663cb9c54a0f4bb7da918cb88cf/rpds_py-0.27.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:50c946f048209e6362e22576baea09193809f87687a95a8db24e5fbdb307b93a", size = 384062, upload-time = "2025-08-27T12:12:34.857Z" },
+    { url = "https://files.pythonhosted.org/packages/69/f7/f47ff154be8d9a5e691c083a920bba89cef88d5247c241c10b9898f595a1/rpds_py-0.27.1-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:3deab27804d65cd8289eb814c2c0e807c4b9d9916c9225e363cb0cf875eb67c1", size = 401289, upload-time = "2025-08-27T12:12:36.085Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/d9/ca410363efd0615814ae579f6829cafb39225cd63e5ea5ed1404cb345293/rpds_py-0.27.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8b61097f7488de4be8244c89915da8ed212832ccf1e7c7753a25a394bf9b1f10", size = 417718, upload-time = "2025-08-27T12:12:37.401Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/a0/8cb5c2ff38340f221cc067cc093d1270e10658ba4e8d263df923daa18e86/rpds_py-0.27.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:8a3f29aba6e2d7d90528d3c792555a93497fe6538aa65eb675b44505be747808", size = 558333, upload-time = "2025-08-27T12:12:38.672Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/8c/1b0de79177c5d5103843774ce12b84caa7164dfc6cd66378768d37db11bf/rpds_py-0.27.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:dd6cd0485b7d347304067153a6dc1d73f7d4fd995a396ef32a24d24b8ac63ac8", size = 589127, upload-time = "2025-08-27T12:12:41.48Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/5e/26abb098d5e01266b0f3a2488d299d19ccc26849735d9d2b95c39397e945/rpds_py-0.27.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:6f4461bf931108c9fa226ffb0e257c1b18dc2d44cd72b125bec50ee0ab1248a9", size = 554899, upload-time = "2025-08-27T12:12:42.925Z" },
+    { url = "https://files.pythonhosted.org/packages/de/41/905cc90ced13550db017f8f20c6d8e8470066c5738ba480d7ba63e3d136b/rpds_py-0.27.1-cp310-cp310-win32.whl", hash = "sha256:ee5422d7fb21f6a00c1901bf6559c49fee13a5159d0288320737bbf6585bd3e4", size = 217450, upload-time = "2025-08-27T12:12:44.813Z" },
+    { url = "https://files.pythonhosted.org/packages/75/3d/6bef47b0e253616ccdf67c283e25f2d16e18ccddd38f92af81d5a3420206/rpds_py-0.27.1-cp310-cp310-win_amd64.whl", hash = "sha256:3e039aabf6d5f83c745d5f9a0a381d031e9ed871967c0a5c38d201aca41f3ba1", size = 228447, upload-time = "2025-08-27T12:12:46.204Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/c1/7907329fbef97cbd49db6f7303893bd1dd5a4a3eae415839ffdfb0762cae/rpds_py-0.27.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:be898f271f851f68b318872ce6ebebbc62f303b654e43bf72683dbdc25b7c881", size = 371063, upload-time = "2025-08-27T12:12:47.856Z" },
+    { url = "https://files.pythonhosted.org/packages/11/94/2aab4bc86228bcf7c48760990273653a4900de89c7537ffe1b0d6097ed39/rpds_py-0.27.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:62ac3d4e3e07b58ee0ddecd71d6ce3b1637de2d373501412df395a0ec5f9beb5", size = 353210, upload-time = "2025-08-27T12:12:49.187Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/57/f5eb3ecf434342f4f1a46009530e93fd201a0b5b83379034ebdb1d7c1a58/rpds_py-0.27.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4708c5c0ceb2d034f9991623631d3d23cb16e65c83736ea020cdbe28d57c0a0e", size = 381636, upload-time = "2025-08-27T12:12:50.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/f4/ef95c5945e2ceb5119571b184dd5a1cc4b8541bbdf67461998cfeac9cb1e/rpds_py-0.27.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:abfa1171a9952d2e0002aba2ad3780820b00cc3d9c98c6630f2e93271501f66c", size = 394341, upload-time = "2025-08-27T12:12:52.024Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/7e/4bd610754bf492d398b61725eb9598ddd5eb86b07d7d9483dbcd810e20bc/rpds_py-0.27.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4b507d19f817ebaca79574b16eb2ae412e5c0835542c93fe9983f1e432aca195", size = 523428, upload-time = "2025-08-27T12:12:53.779Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/e5/059b9f65a8c9149361a8b75094864ab83b94718344db511fd6117936ed2a/rpds_py-0.27.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:168b025f8fd8d8d10957405f3fdcef3dc20f5982d398f90851f4abc58c566c52", size = 402923, upload-time = "2025-08-27T12:12:55.15Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/48/64cabb7daced2968dd08e8a1b7988bf358d7bd5bcd5dc89a652f4668543c/rpds_py-0.27.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb56c6210ef77caa58e16e8c17d35c63fe3f5b60fd9ba9d424470c3400bcf9ed", size = 384094, upload-time = "2025-08-27T12:12:57.194Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/e1/dc9094d6ff566bff87add8a510c89b9e158ad2ecd97ee26e677da29a9e1b/rpds_py-0.27.1-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:d252f2d8ca0195faa707f8eb9368955760880b2b42a8ee16d382bf5dd807f89a", size = 401093, upload-time = "2025-08-27T12:12:58.985Z" },
+    { url = "https://files.pythonhosted.org/packages/37/8e/ac8577e3ecdd5593e283d46907d7011618994e1d7ab992711ae0f78b9937/rpds_py-0.27.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6e5e54da1e74b91dbc7996b56640f79b195d5925c2b78efaa8c5d53e1d88edde", size = 417969, upload-time = "2025-08-27T12:13:00.367Z" },
+    { url = "https://files.pythonhosted.org/packages/66/6d/87507430a8f74a93556fe55c6485ba9c259949a853ce407b1e23fea5ba31/rpds_py-0.27.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ffce0481cc6e95e5b3f0a47ee17ffbd234399e6d532f394c8dce320c3b089c21", size = 558302, upload-time = "2025-08-27T12:13:01.737Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/bb/1db4781ce1dda3eecc735e3152659a27b90a02ca62bfeea17aee45cc0fbc/rpds_py-0.27.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:a205fdfe55c90c2cd8e540ca9ceba65cbe6629b443bc05db1f590a3db8189ff9", size = 589259, upload-time = "2025-08-27T12:13:03.127Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/0e/ae1c8943d11a814d01b482e1f8da903f88047a962dff9bbdadf3bd6e6fd1/rpds_py-0.27.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:689fb5200a749db0415b092972e8eba85847c23885c8543a8b0f5c009b1a5948", size = 554983, upload-time = "2025-08-27T12:13:04.516Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/d5/0b2a55415931db4f112bdab072443ff76131b5ac4f4dc98d10d2d357eb03/rpds_py-0.27.1-cp311-cp311-win32.whl", hash = "sha256:3182af66048c00a075010bc7f4860f33913528a4b6fc09094a6e7598e462fe39", size = 217154, upload-time = "2025-08-27T12:13:06.278Z" },
+    { url = "https://files.pythonhosted.org/packages/24/75/3b7ffe0d50dc86a6a964af0d1cc3a4a2cdf437cb7b099a4747bbb96d1819/rpds_py-0.27.1-cp311-cp311-win_amd64.whl", hash = "sha256:b4938466c6b257b2f5c4ff98acd8128ec36b5059e5c8f8372d79316b1c36bb15", size = 228627, upload-time = "2025-08-27T12:13:07.625Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/3f/4fd04c32abc02c710f09a72a30c9a55ea3cc154ef8099078fd50a0596f8e/rpds_py-0.27.1-cp311-cp311-win_arm64.whl", hash = "sha256:2f57af9b4d0793e53266ee4325535a31ba48e2f875da81a9177c9926dfa60746", size = 220998, upload-time = "2025-08-27T12:13:08.972Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/fe/38de28dee5df58b8198c743fe2bea0c785c6d40941b9950bac4cdb71a014/rpds_py-0.27.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:ae2775c1973e3c30316892737b91f9283f9908e3cc7625b9331271eaaed7dc90", size = 361887, upload-time = "2025-08-27T12:13:10.233Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/9a/4b6c7eedc7dd90986bf0fab6ea2a091ec11c01b15f8ba0a14d3f80450468/rpds_py-0.27.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2643400120f55c8a96f7c9d858f7be0c88d383cd4653ae2cf0d0c88f668073e5", size = 345795, upload-time = "2025-08-27T12:13:11.65Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/0e/e650e1b81922847a09cca820237b0edee69416a01268b7754d506ade11ad/rpds_py-0.27.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:16323f674c089b0360674a4abd28d5042947d54ba620f72514d69be4ff64845e", size = 385121, upload-time = "2025-08-27T12:13:13.008Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/ea/b306067a712988e2bff00dcc7c8f31d26c29b6d5931b461aa4b60a013e33/rpds_py-0.27.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9a1f4814b65eacac94a00fc9a526e3fdafd78e439469644032032d0d63de4881", size = 398976, upload-time = "2025-08-27T12:13:14.368Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/0a/26dc43c8840cb8fe239fe12dbc8d8de40f2365e838f3d395835dde72f0e5/rpds_py-0.27.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7ba32c16b064267b22f1850a34051121d423b6f7338a12b9459550eb2096e7ec", size = 525953, upload-time = "2025-08-27T12:13:15.774Z" },
+    { url = "https://files.pythonhosted.org/packages/22/14/c85e8127b573aaf3a0cbd7fbb8c9c99e735a4a02180c84da2a463b766e9e/rpds_py-0.27.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5c20f33fd10485b80f65e800bbe5f6785af510b9f4056c5a3c612ebc83ba6cb", size = 407915, upload-time = "2025-08-27T12:13:17.379Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/7b/8f4fee9ba1fb5ec856eb22d725a4efa3deb47f769597c809e03578b0f9d9/rpds_py-0.27.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:466bfe65bd932da36ff279ddd92de56b042f2266d752719beb97b08526268ec5", size = 386883, upload-time = "2025-08-27T12:13:18.704Z" },
+    { url = "https://files.pythonhosted.org/packages/86/47/28fa6d60f8b74fcdceba81b272f8d9836ac0340570f68f5df6b41838547b/rpds_py-0.27.1-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:41e532bbdcb57c92ba3be62c42e9f096431b4cf478da9bc3bc6ce5c38ab7ba7a", size = 405699, upload-time = "2025-08-27T12:13:20.089Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/fd/c5987b5e054548df56953a21fe2ebed51fc1ec7c8f24fd41c067b68c4a0a/rpds_py-0.27.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f149826d742b406579466283769a8ea448eed82a789af0ed17b0cd5770433444", size = 423713, upload-time = "2025-08-27T12:13:21.436Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ba/3c4978b54a73ed19a7d74531be37a8bcc542d917c770e14d372b8daea186/rpds_py-0.27.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:80c60cfb5310677bd67cb1e85a1e8eb52e12529545441b43e6f14d90b878775a", size = 562324, upload-time = "2025-08-27T12:13:22.789Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/6c/6943a91768fec16db09a42b08644b960cff540c66aab89b74be6d4a144ba/rpds_py-0.27.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:7ee6521b9baf06085f62ba9c7a3e5becffbc32480d2f1b351559c001c38ce4c1", size = 593646, upload-time = "2025-08-27T12:13:24.122Z" },
+    { url = "https://files.pythonhosted.org/packages/11/73/9d7a8f4be5f4396f011a6bb7a19fe26303a0dac9064462f5651ced2f572f/rpds_py-0.27.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a512c8263249a9d68cac08b05dd59d2b3f2061d99b322813cbcc14c3c7421998", size = 558137, upload-time = "2025-08-27T12:13:25.557Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/96/6772cbfa0e2485bcceef8071de7821f81aeac8bb45fbfd5542a3e8108165/rpds_py-0.27.1-cp312-cp312-win32.whl", hash = "sha256:819064fa048ba01b6dadc5116f3ac48610435ac9a0058bbde98e569f9e785c39", size = 221343, upload-time = "2025-08-27T12:13:26.967Z" },
+    { url = "https://files.pythonhosted.org/packages/67/b6/c82f0faa9af1c6a64669f73a17ee0eeef25aff30bb9a1c318509efe45d84/rpds_py-0.27.1-cp312-cp312-win_amd64.whl", hash = "sha256:d9199717881f13c32c4046a15f024971a3b78ad4ea029e8da6b86e5aa9cf4594", size = 232497, upload-time = "2025-08-27T12:13:28.326Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/96/2817b44bd2ed11aebacc9251da03689d56109b9aba5e311297b6902136e2/rpds_py-0.27.1-cp312-cp312-win_arm64.whl", hash = "sha256:33aa65b97826a0e885ef6e278fbd934e98cdcfed80b63946025f01e2f5b29502", size = 222790, upload-time = "2025-08-27T12:13:29.71Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/77/610aeee8d41e39080c7e14afa5387138e3c9fa9756ab893d09d99e7d8e98/rpds_py-0.27.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:e4b9fcfbc021633863a37e92571d6f91851fa656f0180246e84cbd8b3f6b329b", size = 361741, upload-time = "2025-08-27T12:13:31.039Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/fc/c43765f201c6a1c60be2043cbdb664013def52460a4c7adace89d6682bf4/rpds_py-0.27.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1441811a96eadca93c517d08df75de45e5ffe68aa3089924f963c782c4b898cf", size = 345574, upload-time = "2025-08-27T12:13:32.902Z" },
+    { url = "https://files.pythonhosted.org/packages/20/42/ee2b2ca114294cd9847d0ef9c26d2b0851b2e7e00bf14cc4c0b581df0fc3/rpds_py-0.27.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55266dafa22e672f5a4f65019015f90336ed31c6383bd53f5e7826d21a0e0b83", size = 385051, upload-time = "2025-08-27T12:13:34.228Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e8/1e430fe311e4799e02e2d1af7c765f024e95e17d651612425b226705f910/rpds_py-0.27.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d78827d7ac08627ea2c8e02c9e5b41180ea5ea1f747e9db0915e3adf36b62dcf", size = 398395, upload-time = "2025-08-27T12:13:36.132Z" },
+    { url = "https://files.pythonhosted.org/packages/82/95/9dc227d441ff2670651c27a739acb2535ccaf8b351a88d78c088965e5996/rpds_py-0.27.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae92443798a40a92dc5f0b01d8a7c93adde0c4dc965310a29ae7c64d72b9fad2", size = 524334, upload-time = "2025-08-27T12:13:37.562Z" },
+    { url = "https://files.pythonhosted.org/packages/87/01/a670c232f401d9ad461d9a332aa4080cd3cb1d1df18213dbd0d2a6a7ab51/rpds_py-0.27.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c46c9dd2403b66a2a3b9720ec4b74d4ab49d4fabf9f03dfdce2d42af913fe8d0", size = 407691, upload-time = "2025-08-27T12:13:38.94Z" },
+    { url = "https://files.pythonhosted.org/packages/03/36/0a14aebbaa26fe7fab4780c76f2239e76cc95a0090bdb25e31d95c492fcd/rpds_py-0.27.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2efe4eb1d01b7f5f1939f4ef30ecea6c6b3521eec451fb93191bf84b2a522418", size = 386868, upload-time = "2025-08-27T12:13:40.192Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/03/8c897fb8b5347ff6c1cc31239b9611c5bf79d78c984430887a353e1409a1/rpds_py-0.27.1-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:15d3b4d83582d10c601f481eca29c3f138d44c92187d197aff663a269197c02d", size = 405469, upload-time = "2025-08-27T12:13:41.496Z" },
+    { url = "https://files.pythonhosted.org/packages/da/07/88c60edc2df74850d496d78a1fdcdc7b54360a7f610a4d50008309d41b94/rpds_py-0.27.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4ed2e16abbc982a169d30d1a420274a709949e2cbdef119fe2ec9d870b42f274", size = 422125, upload-time = "2025-08-27T12:13:42.802Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/86/5f4c707603e41b05f191a749984f390dabcbc467cf833769b47bf14ba04f/rpds_py-0.27.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a75f305c9b013289121ec0f1181931975df78738cdf650093e6b86d74aa7d8dd", size = 562341, upload-time = "2025-08-27T12:13:44.472Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/92/3c0cb2492094e3cd9baf9e49bbb7befeceb584ea0c1a8b5939dca4da12e5/rpds_py-0.27.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:67ce7620704745881a3d4b0ada80ab4d99df390838839921f99e63c474f82cf2", size = 592511, upload-time = "2025-08-27T12:13:45.898Z" },
+    { url = "https://files.pythonhosted.org/packages/10/bb/82e64fbb0047c46a168faa28d0d45a7851cd0582f850b966811d30f67ad8/rpds_py-0.27.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9d992ac10eb86d9b6f369647b6a3f412fc0075cfd5d799530e84d335e440a002", size = 557736, upload-time = "2025-08-27T12:13:47.408Z" },
+    { url = "https://files.pythonhosted.org/packages/00/95/3c863973d409210da7fb41958172c6b7dbe7fc34e04d3cc1f10bb85e979f/rpds_py-0.27.1-cp313-cp313-win32.whl", hash = "sha256:4f75e4bd8ab8db624e02c8e2fc4063021b58becdbe6df793a8111d9343aec1e3", size = 221462, upload-time = "2025-08-27T12:13:48.742Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/2c/5867b14a81dc217b56d95a9f2a40fdbc56a1ab0181b80132beeecbd4b2d6/rpds_py-0.27.1-cp313-cp313-win_amd64.whl", hash = "sha256:f9025faafc62ed0b75a53e541895ca272815bec18abe2249ff6501c8f2e12b83", size = 232034, upload-time = "2025-08-27T12:13:50.11Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/78/3958f3f018c01923823f1e47f1cc338e398814b92d83cd278364446fac66/rpds_py-0.27.1-cp313-cp313-win_arm64.whl", hash = "sha256:ed10dc32829e7d222b7d3b93136d25a406ba9788f6a7ebf6809092da1f4d279d", size = 222392, upload-time = "2025-08-27T12:13:52.587Z" },
+    { url = "https://files.pythonhosted.org/packages/01/76/1cdf1f91aed5c3a7bf2eba1f1c4e4d6f57832d73003919a20118870ea659/rpds_py-0.27.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:92022bbbad0d4426e616815b16bc4127f83c9a74940e1ccf3cfe0b387aba0228", size = 358355, upload-time = "2025-08-27T12:13:54.012Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/6f/bf142541229374287604caf3bb2a4ae17f0a580798fd72d3b009b532db4e/rpds_py-0.27.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:47162fdab9407ec3f160805ac3e154df042e577dd53341745fc7fb3f625e6d92", size = 342138, upload-time = "2025-08-27T12:13:55.791Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/77/355b1c041d6be40886c44ff5e798b4e2769e497b790f0f7fd1e78d17e9a8/rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb89bec23fddc489e5d78b550a7b773557c9ab58b7946154a10a6f7a214a48b2", size = 380247, upload-time = "2025-08-27T12:13:57.683Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/a4/d9cef5c3946ea271ce2243c51481971cd6e34f21925af2783dd17b26e815/rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e48af21883ded2b3e9eb48cb7880ad8598b31ab752ff3be6457001d78f416723", size = 390699, upload-time = "2025-08-27T12:13:59.137Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/06/005106a7b8c6c1a7e91b73169e49870f4af5256119d34a361ae5240a0c1d/rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6f5b7bd8e219ed50299e58551a410b64daafb5017d54bbe822e003856f06a802", size = 521852, upload-time = "2025-08-27T12:14:00.583Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/3e/50fb1dac0948e17a02eb05c24510a8fe12d5ce8561c6b7b7d1339ab7ab9c/rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08f1e20bccf73b08d12d804d6e1c22ca5530e71659e6673bce31a6bb71c1e73f", size = 402582, upload-time = "2025-08-27T12:14:02.034Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/b0/f4e224090dc5b0ec15f31a02d746ab24101dd430847c4d99123798661bfc/rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0dc5dceeaefcc96dc192e3a80bbe1d6c410c469e97bdd47494a7d930987f18b2", size = 384126, upload-time = "2025-08-27T12:14:03.437Z" },
+    { url = "https://files.pythonhosted.org/packages/54/77/ac339d5f82b6afff1df8f0fe0d2145cc827992cb5f8eeb90fc9f31ef7a63/rpds_py-0.27.1-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:d76f9cc8665acdc0c9177043746775aa7babbf479b5520b78ae4002d889f5c21", size = 399486, upload-time = "2025-08-27T12:14:05.443Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/29/3e1c255eee6ac358c056a57d6d6869baa00a62fa32eea5ee0632039c50a3/rpds_py-0.27.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:134fae0e36022edad8290a6661edf40c023562964efea0cc0ec7f5d392d2aaef", size = 414832, upload-time = "2025-08-27T12:14:06.902Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/db/6d498b844342deb3fa1d030598db93937a9964fcf5cb4da4feb5f17be34b/rpds_py-0.27.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:eb11a4f1b2b63337cfd3b4d110af778a59aae51c81d195768e353d8b52f88081", size = 557249, upload-time = "2025-08-27T12:14:08.37Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f3/690dd38e2310b6f68858a331399b4d6dbb9132c3e8ef8b4333b96caf403d/rpds_py-0.27.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:13e608ac9f50a0ed4faec0e90ece76ae33b34c0e8656e3dceb9a7db994c692cd", size = 587356, upload-time = "2025-08-27T12:14:10.034Z" },
+    { url = "https://files.pythonhosted.org/packages/86/e3/84507781cccd0145f35b1dc32c72675200c5ce8d5b30f813e49424ef68fc/rpds_py-0.27.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dd2135527aa40f061350c3f8f89da2644de26cd73e4de458e79606384f4f68e7", size = 555300, upload-time = "2025-08-27T12:14:11.783Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/ee/375469849e6b429b3516206b4580a79e9ef3eb12920ddbd4492b56eaacbe/rpds_py-0.27.1-cp313-cp313t-win32.whl", hash = "sha256:3020724ade63fe320a972e2ffd93b5623227e684315adce194941167fee02688", size = 216714, upload-time = "2025-08-27T12:14:13.629Z" },
+    { url = "https://files.pythonhosted.org/packages/21/87/3fc94e47c9bd0742660e84706c311a860dcae4374cf4a03c477e23ce605a/rpds_py-0.27.1-cp313-cp313t-win_amd64.whl", hash = "sha256:8ee50c3e41739886606388ba3ab3ee2aae9f35fb23f833091833255a31740797", size = 228943, upload-time = "2025-08-27T12:14:14.937Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/63/b7cc415c345625d5e62f694ea356c58fb964861409008118f1245f8c3347/rpds_py-0.27.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:7ba22cb9693df986033b91ae1d7a979bc399237d45fccf875b76f62bb9e52ddf", size = 371360, upload-time = "2025-08-27T12:15:29.218Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/8c/12e1b24b560cf378b8ffbdb9dc73abd529e1adcfcf82727dfd29c4a7b88d/rpds_py-0.27.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5b640501be9288c77738b5492b3fd3abc4ba95c50c2e41273c8a1459f08298d3", size = 353933, upload-time = "2025-08-27T12:15:30.837Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/85/1bb2210c1f7a1b99e91fea486b9f0f894aa5da3a5ec7097cbad7dec6d40f/rpds_py-0.27.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb08b65b93e0c6dd70aac7f7890a9c0938d5ec71d5cb32d45cf844fb8ae47636", size = 382962, upload-time = "2025-08-27T12:15:32.348Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/c9/a839b9f219cf80ed65f27a7f5ddbb2809c1b85c966020ae2dff490e0b18e/rpds_py-0.27.1-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d7ff07d696a7a38152ebdb8212ca9e5baab56656749f3d6004b34ab726b550b8", size = 394412, upload-time = "2025-08-27T12:15:33.839Z" },
+    { url = "https://files.pythonhosted.org/packages/02/2d/b1d7f928b0b1f4fc2e0133e8051d199b01d7384875adc63b6ddadf3de7e5/rpds_py-0.27.1-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fb7c72262deae25366e3b6c0c0ba46007967aea15d1eea746e44ddba8ec58dcc", size = 523972, upload-time = "2025-08-27T12:15:35.377Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/af/2cbf56edd2d07716df1aec8a726b3159deb47cb5c27e1e42b71d705a7c2f/rpds_py-0.27.1-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7b002cab05d6339716b03a4a3a2ce26737f6231d7b523f339fa061d53368c9d8", size = 403273, upload-time = "2025-08-27T12:15:37.051Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/93/425e32200158d44ff01da5d9612c3b6711fe69f606f06e3895511f17473b/rpds_py-0.27.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:23f6b69d1c26c4704fec01311963a41d7de3ee0570a84ebde4d544e5a1859ffc", size = 385278, upload-time = "2025-08-27T12:15:38.571Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/1a/1a04a915ecd0551bfa9e77b7672d1937b4b72a0fc204a17deef76001cfb2/rpds_py-0.27.1-pp310-pypy310_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:530064db9146b247351f2a0250b8f00b289accea4596a033e94be2389977de71", size = 402084, upload-time = "2025-08-27T12:15:40.529Z" },
+    { url = "https://files.pythonhosted.org/packages/51/f7/66585c0fe5714368b62951d2513b684e5215beaceab2c6629549ddb15036/rpds_py-0.27.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7b90b0496570bd6b0321724a330d8b545827c4df2034b6ddfc5f5275f55da2ad", size = 419041, upload-time = "2025-08-27T12:15:42.191Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/7e/83a508f6b8e219bba2d4af077c35ba0e0cdd35a751a3be6a7cba5a55ad71/rpds_py-0.27.1-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:879b0e14a2da6a1102a3fc8af580fc1ead37e6d6692a781bd8c83da37429b5ab", size = 560084, upload-time = "2025-08-27T12:15:43.839Z" },
+    { url = "https://files.pythonhosted.org/packages/66/66/bb945683b958a1b19eb0fe715594630d0f36396ebdef4d9b89c2fa09aa56/rpds_py-0.27.1-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:0d807710df3b5faa66c731afa162ea29717ab3be17bdc15f90f2d9f183da4059", size = 590115, upload-time = "2025-08-27T12:15:46.647Z" },
+    { url = "https://files.pythonhosted.org/packages/12/00/ccfaafaf7db7e7adace915e5c2f2c2410e16402561801e9c7f96683002d3/rpds_py-0.27.1-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:3adc388fc3afb6540aec081fa59e6e0d3908722771aa1e37ffe22b220a436f0b", size = 556561, upload-time = "2025-08-27T12:15:48.219Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/b7/92b6ed9aad103bfe1c45df98453dfae40969eef2cb6c6239c58d7e96f1b3/rpds_py-0.27.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:c796c0c1cc68cb08b0284db4229f5af76168172670c74908fdbd4b7d7f515819", size = 229125, upload-time = "2025-08-27T12:15:49.956Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ed/e1fba02de17f4f76318b834425257c8ea297e415e12c68b4361f63e8ae92/rpds_py-0.27.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:cdfe4bb2f9fe7458b7453ad3c33e726d6d1c7c0a72960bcc23800d77384e42df", size = 371402, upload-time = "2025-08-27T12:15:51.561Z" },
+    { url = "https://files.pythonhosted.org/packages/af/7c/e16b959b316048b55585a697e94add55a4ae0d984434d279ea83442e460d/rpds_py-0.27.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:8fabb8fd848a5f75a2324e4a84501ee3a5e3c78d8603f83475441866e60b94a3", size = 354084, upload-time = "2025-08-27T12:15:53.219Z" },
+    { url = "https://files.pythonhosted.org/packages/de/c1/ade645f55de76799fdd08682d51ae6724cb46f318573f18be49b1e040428/rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eda8719d598f2f7f3e0f885cba8646644b55a187762bec091fa14a2b819746a9", size = 383090, upload-time = "2025-08-27T12:15:55.158Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/27/89070ca9b856e52960da1472efcb6c20ba27cfe902f4f23ed095b9cfc61d/rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3c64d07e95606ec402a0a1c511fe003873fa6af630bda59bac77fac8b4318ebc", size = 394519, upload-time = "2025-08-27T12:15:57.238Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/28/be120586874ef906aa5aeeae95ae8df4184bc757e5b6bd1c729ccff45ed5/rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:93a2ed40de81bcff59aabebb626562d48332f3d028ca2036f1d23cbb52750be4", size = 523817, upload-time = "2025-08-27T12:15:59.237Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/ef/70cc197bc11cfcde02a86f36ac1eed15c56667c2ebddbdb76a47e90306da/rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:387ce8c44ae94e0ec50532d9cb0edce17311024c9794eb196b90e1058aadeb66", size = 403240, upload-time = "2025-08-27T12:16:00.923Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/35/46936cca449f7f518f2f4996e0e8344db4b57e2081e752441154089d2a5f/rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aaf94f812c95b5e60ebaf8bfb1898a7d7cb9c1af5744d4a67fa47796e0465d4e", size = 385194, upload-time = "2025-08-27T12:16:02.802Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/62/29c0d3e5125c3270b51415af7cbff1ec587379c84f55a5761cc9efa8cd06/rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:4848ca84d6ded9b58e474dfdbad4b8bfb450344c0551ddc8d958bf4b36aa837c", size = 402086, upload-time = "2025-08-27T12:16:04.806Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/66/03e1087679227785474466fdd04157fb793b3b76e3fcf01cbf4c693c1949/rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2bde09cbcf2248b73c7c323be49b280180ff39fadcfe04e7b6f54a678d02a7cf", size = 419272, upload-time = "2025-08-27T12:16:06.471Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/24/e3e72d265121e00b063aef3e3501e5b2473cf1b23511d56e529531acf01e/rpds_py-0.27.1-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:94c44ee01fd21c9058f124d2d4f0c9dc7634bec93cd4b38eefc385dabe71acbf", size = 560003, upload-time = "2025-08-27T12:16:08.06Z" },
+    { url = "https://files.pythonhosted.org/packages/26/ca/f5a344c534214cc2d41118c0699fffbdc2c1bc7046f2a2b9609765ab9c92/rpds_py-0.27.1-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:df8b74962e35c9249425d90144e721eed198e6555a0e22a563d29fe4486b51f6", size = 590482, upload-time = "2025-08-27T12:16:10.137Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/08/4349bdd5c64d9d193c360aa9db89adeee6f6682ab8825dca0a3f535f434f/rpds_py-0.27.1-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:dc23e6820e3b40847e2f4a7726462ba0cf53089512abe9ee16318c366494c17a", size = 556523, upload-time = "2025-08-27T12:16:12.188Z" },
+]
+
+[[package]]
+name = "rsl-rl-lib"
+version = "5.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "gitpython" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "onnx" },
+    { name = "onnxscript" },
+    { name = "tensorboard" },
+    { name = "tensordict" },
+    { name = "torch", version = "2.9.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform == 'darwin' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128')" },
+    { name = "torch", version = "2.9.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "torch", version = "2.10.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/47/4d/9e015172774bc07e14f72b82bbc9fd9ab9ac65cfbdfe70844ba344ed3c43/rsl_rl_lib-5.5.0.tar.gz", hash = "sha256:26b5f2e8ee6f2d5bda38d4cc5e5b6420aa60cdbf108b1c131ac4a008bb29d943", size = 67466, upload-time = "2026-08-27T07:13:02.614Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4e/55/bb460ef8188f4cef79df2bd0103897a87aa6cd81018bb696fe7afe22f2b0/rsl_rl_lib-5.5.0-py3-none-any.whl", hash = "sha256:95b716da32e19055596f1d3bcf24f02e13bdadf4b9ffffacc22a832239e60255", size = 99594, upload-time = "2026-08-27T07:13:01.164Z" },
+]
+
+[[package]]
+name = "rtree"
+version = "1.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/09/7302695875a019514de9a5dd17b8320e7a19d6e7bc8f85dcfb79a4ce2da3/rtree-1.4.1.tar.gz", hash = "sha256:c6b1b3550881e57ebe530cc6cffefc87cd9bf49c30b37b894065a9f810875e46", size = 52425, upload-time = "2025-08-13T19:32:01.413Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/d9/108cd989a4c0954e60b3cdc86fd2826407702b5375f6dfdab2802e5fed98/rtree-1.4.1-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:d672184298527522d4914d8ae53bf76982b86ca420b0acde9298a7a87d81d4a4", size = 468484, upload-time = "2025-08-13T19:31:50.593Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/cf/2710b6fd6b07ea0aef317b29f335790ba6adf06a28ac236078ed9bd8a91d/rtree-1.4.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:a7e48d805e12011c2cf739a29d6a60ae852fb1de9fc84220bbcef67e6e595d7d", size = 436325, upload-time = "2025-08-13T19:31:52.367Z" },
+    { url = "https://files.pythonhosted.org/packages/55/e1/4d075268a46e68db3cac51846eb6a3ab96ed481c585c5a1ad411b3c23aad/rtree-1.4.1-py3-none-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:efa8c4496e31e9ad58ff6c7df89abceac7022d906cb64a3e18e4fceae6b77f65", size = 459789, upload-time = "2025-08-13T19:31:53.926Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/75/e5d44be90525cd28503e7f836d077ae6663ec0687a13ba7810b4114b3668/rtree-1.4.1-py3-none-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:12de4578f1b3381a93a655846900be4e3d5f4cd5e306b8b00aa77c1121dc7e8c", size = 507644, upload-time = "2025-08-13T19:31:55.164Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/85/b8684f769a142163b52859a38a486493b05bafb4f2fb71d4f945de28ebf9/rtree-1.4.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:b558edda52eca3e6d1ee629042192c65e6b7f2c150d6d6cd207ce82f85be3967", size = 1454478, upload-time = "2025-08-13T19:31:56.808Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/a4/c2292b95246b9165cc43a0c3757e80995d58bc9b43da5cb47ad6e3535213/rtree-1.4.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:f155bc8d6bac9dcd383481dee8c130947a4866db1d16cb6dff442329a038a0dc", size = 1555140, upload-time = "2025-08-13T19:31:58.031Z" },
+    { url = "https://files.pythonhosted.org/packages/74/25/5282c8270bfcd620d3e73beb35b40ac4ab00f0a898d98ebeb41ef0989ec8/rtree-1.4.1-py3-none-win_amd64.whl", hash = "sha256:efe125f416fd27150197ab8521158662943a40f87acab8028a1aac4ad667a489", size = 389358, upload-time = "2025-08-13T19:31:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/50/0a9e7e7afe7339bd5e36911f0ceb15fed51945836ed803ae5afd661057fd/rtree-1.4.1-py3-none-win_arm64.whl", hash = "sha256:3d46f55729b28138e897ffef32f7ce93ac335cb67f9120125ad3742a220800f0", size = 355253, upload-time = "2025-08-13T19:32:00.296Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.16.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/70/25/7113f6d5498888c5fb7db34081cba7d5971c4cb1bfb26819966eee68f003/ruff-0.16.1.tar.gz", hash = "sha256:fedad7c801dabd3fb9741d76aca39246e6ddd9ca446a015875207bf19f1e6bc7", size = 4877500, upload-time = "2026-07-30T19:37:01.379Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/bd/694da69368e0973de65df2ddc73ab18d43c469d5963d9b150911de6bc513/ruff-0.16.1-py3-none-linux_armv6l.whl", hash = "sha256:58edb313b88f0c5460a26adf5f39a37a3be789494a15e3e411e35fa78b89f9a0", size = 10839126, upload-time = "2026-07-30T19:36:13.697Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/f0/b626e5d5bd0dd9576263658ef12885e2288afd1029a48e26ffed65ec1ac1/ruff-0.16.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:fde5a99e2f97479af66edd6622c6d5a2a7592c77cf4153d9e4428f5eeb55b60c", size = 11070253, upload-time = "2026-07-30T19:36:17.14Z" },
+    { url = "https://files.pythonhosted.org/packages/83/63/f40acfb6b35b88623e71684942b552c3edd96035f5d98f313815f7b277de/ruff-0.16.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:e0d4c20532fca4f7fa609369161d968dd28f65d83dabbd61d8e9c7edbf7001f6", size = 10561425, upload-time = "2026-07-30T19:36:20.04Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/dd/14ec0e9c2b4d315547dd38765004b4863e354e1b52cb308272215d9f6f6d/ruff-0.16.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:30affbcedf59ad5703d9c91f82266e02b47739f797e1a7b6e158e5526a6dae38", size = 10948879, upload-time = "2026-07-30T19:36:22.476Z" },
+    { url = "https://files.pythonhosted.org/packages/33/e9/9d870cbae575030fdef595f04b4b97573c525b5497cce4f4498cf2f85446/ruff-0.16.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:24e9c631573cbca9d20f1283f8f479b2afa4a8503504822bd71a293889f16743", size = 10643691, upload-time = "2026-07-30T19:36:24.914Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/09/12743d544e2173f53ecd27217c65f90d2bc0f8424a66a60339e56bbc0457/ruff-0.16.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b41bdd48fb420987a9b5212e4957c26ad4abce401fa9ea9d4d85843727945f4f", size = 11435354, upload-time = "2026-07-30T19:36:28.447Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/89/a1652b2daee52083c9554a6333b678a8b01d0400f976827bb87857f9449a/ruff-0.16.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b0d1e1393b7648079e13669de1c1f4fde06d4583e84d8fd5c1551e0a77a2aa75", size = 12259033, upload-time = "2026-07-30T19:36:31.326Z" },
+    { url = "https://files.pythonhosted.org/packages/16/96/ecdcb8c54ee7b123b487f807eb014e6e019155a0b81dfb669acd52f28ce3/ruff-0.16.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:07bf434b1c95f4e093be4532068ef4fcf00924eb2ade8796075980902d6fd54a", size = 11667981, upload-time = "2026-07-30T19:36:34.394Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/90/c52e12e0d862e9572f2a33aa227409143520abe53111e9a6babbac7b4af8/ruff-0.16.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39897739f112253ee4fdd2e8aa9a4f9ded99fb2be367d5f31dfa4ded6025584c", size = 11468183, upload-time = "2026-07-30T19:36:37.339Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/6b/4ffb7ad1d83eb16cf8cbb3c8815d3f11c88460fd162d4b372a2059be1c2a/ruff-0.16.1-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:82ae3c0c0d74daf17b968a10b7b3bb3ef297ab7de0c1f749646b25e690ccb150", size = 11470071, upload-time = "2026-07-30T19:36:39.91Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/72/32ae7db4c0b5e32ab611787caa19d1546800676d79f7483b7100a3561bf4/ruff-0.16.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:4d5f2ed10f8242d83fc08d521301089364e3375375705356f20c0e31606ef3ef", size = 10919503, upload-time = "2026-07-30T19:36:42.65Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/ca/3d901ba6ad6fc38da39c3448fc6c59ac945679293a17c3ceb6d6c1cba13e/ruff-0.16.1-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:a4665b309891f83f3e3c25447935f1213e9abbd4b5640af7a1f2def9f8d413c1", size = 10649861, upload-time = "2026-07-30T19:36:45.18Z" },
+    { url = "https://files.pythonhosted.org/packages/92/79/894ef1ced26552d5f8c9cf6d85b0687840e1128c55aeab7b9c2d54a0d880/ruff-0.16.1-py3-none-musllinux_1_2_i686.whl", hash = "sha256:26e9ca5c9bc3971f20d3cf18a957f52ffd6a5f6564ff15c4912a144dcac22494", size = 11148137, upload-time = "2026-07-30T19:36:47.936Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/69/3609a09fa1cb46cc28b762363e440a354204e5dff01bd0c8d7437874d6b9/ruff-0.16.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:67e1e1e3fa4f0c82f0e36d4cd61e661f6e7a6196cb1aa92fe0828fa7b8f257cd", size = 11559211, upload-time = "2026-07-30T19:36:50.448Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/8a/fb22af2fd78a736e241fabf67e30ce1799a64244026377a49e133af90762/ruff-0.16.1-py3-none-win32.whl", hash = "sha256:d31765e131295b8445caf301e3e8a85b34d1b9b211b4109b7ba457888b051806", size = 10838258, upload-time = "2026-07-30T19:36:53.298Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/35/e57fd9fb5d423961df087a00b12d42c0a830288dc2f3b45ecca299158b4f/ruff-0.16.1-py3-none-win_amd64.whl", hash = "sha256:09b05e8b90c2cb06ad63464350e7a45e8e44a2dfe52072ebfba6666ca8d3f596", size = 11961111, upload-time = "2026-07-30T19:36:56.107Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/46/240ea004bf6dc4feb40e9832f2205a476a47dd5b8a3f8211a5fc5f95e20e/ruff-0.16.1-py3-none-win_arm64.whl", hash = "sha256:dbaadaac38c70239f056d306b7476f246b0bf000fa6b3876402acbf5b227eaf8", size = 11309414, upload-time = "2026-07-30T19:36:58.79Z" },
+]
+
+[[package]]
+name = "scipy"
+version = "1.15.3"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0f/37/6964b830433e654ec7485e45a00fc9a27cf868d622838f6b6d9c5ec0d532/scipy-1.15.3.tar.gz", hash = "sha256:eae3cf522bc7df64b42cad3925c876e1b0b6c35c1337c93e12c0f366f55b0eaf", size = 59419214, upload-time = "2025-05-08T16:13:05.955Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/2f/4966032c5f8cc7e6a60f1b2e0ad686293b9474b65246b0c642e3ef3badd0/scipy-1.15.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:a345928c86d535060c9c2b25e71e87c39ab2f22fc96e9636bd74d1dbf9de448c", size = 38702770, upload-time = "2025-05-08T16:04:20.849Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/6e/0c3bf90fae0e910c274db43304ebe25a6b391327f3f10b5dcc638c090795/scipy-1.15.3-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:ad3432cb0f9ed87477a8d97f03b763fd1d57709f1bbde3c9369b1dff5503b253", size = 30094511, upload-time = "2025-05-08T16:04:27.103Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/b1/4deb37252311c1acff7f101f6453f0440794f51b6eacb1aad4459a134081/scipy-1.15.3-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:aef683a9ae6eb00728a542b796f52a5477b78252edede72b8327a886ab63293f", size = 22368151, upload-time = "2025-05-08T16:04:31.731Z" },
+    { url = "https://files.pythonhosted.org/packages/38/7d/f457626e3cd3c29b3a49ca115a304cebb8cc6f31b04678f03b216899d3c6/scipy-1.15.3-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:1c832e1bd78dea67d5c16f786681b28dd695a8cb1fb90af2e27580d3d0967e92", size = 25121732, upload-time = "2025-05-08T16:04:36.596Z" },
+    { url = "https://files.pythonhosted.org/packages/db/0a/92b1de4a7adc7a15dcf5bddc6e191f6f29ee663b30511ce20467ef9b82e4/scipy-1.15.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:263961f658ce2165bbd7b99fa5135195c3a12d9bef045345016b8b50c315cb82", size = 35547617, upload-time = "2025-05-08T16:04:43.546Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/6d/41991e503e51fc1134502694c5fa7a1671501a17ffa12716a4a9151af3df/scipy-1.15.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e2abc762b0811e09a0d3258abee2d98e0c703eee49464ce0069590846f31d40", size = 37662964, upload-time = "2025-05-08T16:04:49.431Z" },
+    { url = "https://files.pythonhosted.org/packages/25/e1/3df8f83cb15f3500478c889be8fb18700813b95e9e087328230b98d547ff/scipy-1.15.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ed7284b21a7a0c8f1b6e5977ac05396c0d008b89e05498c8b7e8f4a1423bba0e", size = 37238749, upload-time = "2025-05-08T16:04:55.215Z" },
+    { url = "https://files.pythonhosted.org/packages/93/3e/b3257cf446f2a3533ed7809757039016b74cd6f38271de91682aa844cfc5/scipy-1.15.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5380741e53df2c566f4d234b100a484b420af85deb39ea35a1cc1be84ff53a5c", size = 40022383, upload-time = "2025-05-08T16:05:01.914Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/84/55bc4881973d3f79b479a5a2e2df61c8c9a04fcb986a213ac9c02cfb659b/scipy-1.15.3-cp310-cp310-win_amd64.whl", hash = "sha256:9d61e97b186a57350f6d6fd72640f9e99d5a4a2b8fbf4b9ee9a841eab327dc13", size = 41259201, upload-time = "2025-05-08T16:05:08.166Z" },
+    { url = "https://files.pythonhosted.org/packages/96/ab/5cc9f80f28f6a7dff646c5756e559823614a42b1939d86dd0ed550470210/scipy-1.15.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:993439ce220d25e3696d1b23b233dd010169b62f6456488567e830654ee37a6b", size = 38714255, upload-time = "2025-05-08T16:05:14.596Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/4a/66ba30abe5ad1a3ad15bfb0b59d22174012e8056ff448cb1644deccbfed2/scipy-1.15.3-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:34716e281f181a02341ddeaad584205bd2fd3c242063bd3423d61ac259ca7eba", size = 30111035, upload-time = "2025-05-08T16:05:20.152Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/fa/a7e5b95afd80d24313307f03624acc65801846fa75599034f8ceb9e2cbf6/scipy-1.15.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3b0334816afb8b91dab859281b1b9786934392aa3d527cd847e41bb6f45bee65", size = 22384499, upload-time = "2025-05-08T16:05:24.494Z" },
+    { url = "https://files.pythonhosted.org/packages/17/99/f3aaddccf3588bb4aea70ba35328c204cadd89517a1612ecfda5b2dd9d7a/scipy-1.15.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:6db907c7368e3092e24919b5e31c76998b0ce1684d51a90943cb0ed1b4ffd6c1", size = 25152602, upload-time = "2025-05-08T16:05:29.313Z" },
+    { url = "https://files.pythonhosted.org/packages/56/c5/1032cdb565f146109212153339f9cb8b993701e9fe56b1c97699eee12586/scipy-1.15.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:721d6b4ef5dc82ca8968c25b111e307083d7ca9091bc38163fb89243e85e3889", size = 35503415, upload-time = "2025-05-08T16:05:34.699Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/37/89f19c8c05505d0601ed5650156e50eb881ae3918786c8fd7262b4ee66d3/scipy-1.15.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39cb9c62e471b1bb3750066ecc3a3f3052b37751c7c3dfd0fd7e48900ed52982", size = 37652622, upload-time = "2025-05-08T16:05:40.762Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/31/be59513aa9695519b18e1851bb9e487de66f2d31f835201f1b42f5d4d475/scipy-1.15.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:795c46999bae845966368a3c013e0e00947932d68e235702b5c3f6ea799aa8c9", size = 37244796, upload-time = "2025-05-08T16:05:48.119Z" },
+    { url = "https://files.pythonhosted.org/packages/10/c0/4f5f3eeccc235632aab79b27a74a9130c6c35df358129f7ac8b29f562ac7/scipy-1.15.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:18aaacb735ab38b38db42cb01f6b92a2d0d4b6aabefeb07f02849e47f8fb3594", size = 40047684, upload-time = "2025-05-08T16:05:54.22Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/a7/0ddaf514ce8a8714f6ed243a2b391b41dbb65251affe21ee3077ec45ea9a/scipy-1.15.3-cp311-cp311-win_amd64.whl", hash = "sha256:ae48a786a28412d744c62fd7816a4118ef97e5be0bee968ce8f0a2fba7acf3bb", size = 41246504, upload-time = "2025-05-08T16:06:00.437Z" },
+    { url = "https://files.pythonhosted.org/packages/37/4b/683aa044c4162e10ed7a7ea30527f2cbd92e6999c10a8ed8edb253836e9c/scipy-1.15.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6ac6310fdbfb7aa6612408bd2f07295bcbd3fda00d2d702178434751fe48e019", size = 38766735, upload-time = "2025-05-08T16:06:06.471Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/7e/f30be3d03de07f25dc0ec926d1681fed5c732d759ac8f51079708c79e680/scipy-1.15.3-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:185cd3d6d05ca4b44a8f1595af87f9c372bb6acf9c808e99aa3e9aa03bd98cf6", size = 30173284, upload-time = "2025-05-08T16:06:11.686Z" },
+    { url = "https://files.pythonhosted.org/packages/07/9c/0ddb0d0abdabe0d181c1793db51f02cd59e4901da6f9f7848e1f96759f0d/scipy-1.15.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:05dc6abcd105e1a29f95eada46d4a3f251743cfd7d3ae8ddb4088047f24ea477", size = 22446958, upload-time = "2025-05-08T16:06:15.97Z" },
+    { url = "https://files.pythonhosted.org/packages/af/43/0bce905a965f36c58ff80d8bea33f1f9351b05fad4beaad4eae34699b7a1/scipy-1.15.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:06efcba926324df1696931a57a176c80848ccd67ce6ad020c810736bfd58eb1c", size = 25242454, upload-time = "2025-05-08T16:06:20.394Z" },
+    { url = "https://files.pythonhosted.org/packages/56/30/a6f08f84ee5b7b28b4c597aca4cbe545535c39fe911845a96414700b64ba/scipy-1.15.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c05045d8b9bfd807ee1b9f38761993297b10b245f012b11b13b91ba8945f7e45", size = 35210199, upload-time = "2025-05-08T16:06:26.159Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/1f/03f52c282437a168ee2c7c14a1a0d0781a9a4a8962d84ac05c06b4c5b555/scipy-1.15.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:271e3713e645149ea5ea3e97b57fdab61ce61333f97cfae392c28ba786f9bb49", size = 37309455, upload-time = "2025-05-08T16:06:32.778Z" },
+    { url = "https://files.pythonhosted.org/packages/89/b1/fbb53137f42c4bf630b1ffdfc2151a62d1d1b903b249f030d2b1c0280af8/scipy-1.15.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6cfd56fc1a8e53f6e89ba3a7a7251f7396412d655bca2aa5611c8ec9a6784a1e", size = 36885140, upload-time = "2025-05-08T16:06:39.249Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/2e/025e39e339f5090df1ff266d021892694dbb7e63568edcfe43f892fa381d/scipy-1.15.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0ff17c0bb1cb32952c09217d8d1eed9b53d1463e5f1dd6052c7857f83127d539", size = 39710549, upload-time = "2025-05-08T16:06:45.729Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/eb/3bf6ea8ab7f1503dca3a10df2e4b9c3f6b3316df07f6c0ded94b281c7101/scipy-1.15.3-cp312-cp312-win_amd64.whl", hash = "sha256:52092bc0472cfd17df49ff17e70624345efece4e1a12b23783a1ac59a1b728ed", size = 40966184, upload-time = "2025-05-08T16:06:52.623Z" },
+    { url = "https://files.pythonhosted.org/packages/73/18/ec27848c9baae6e0d6573eda6e01a602e5649ee72c27c3a8aad673ebecfd/scipy-1.15.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2c620736bcc334782e24d173c0fdbb7590a0a436d2fdf39310a8902505008759", size = 38728256, upload-time = "2025-05-08T16:06:58.696Z" },
+    { url = "https://files.pythonhosted.org/packages/74/cd/1aef2184948728b4b6e21267d53b3339762c285a46a274ebb7863c9e4742/scipy-1.15.3-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:7e11270a000969409d37ed399585ee530b9ef6aa99d50c019de4cb01e8e54e62", size = 30109540, upload-time = "2025-05-08T16:07:04.209Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/d8/59e452c0a255ec352bd0a833537a3bc1bfb679944c4938ab375b0a6b3a3e/scipy-1.15.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:8c9ed3ba2c8a2ce098163a9bdb26f891746d02136995df25227a20e71c396ebb", size = 22383115, upload-time = "2025-05-08T16:07:08.998Z" },
+    { url = "https://files.pythonhosted.org/packages/08/f5/456f56bbbfccf696263b47095291040655e3cbaf05d063bdc7c7517f32ac/scipy-1.15.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:0bdd905264c0c9cfa74a4772cdb2070171790381a5c4d312c973382fc6eaf730", size = 25163884, upload-time = "2025-05-08T16:07:14.091Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/66/a9618b6a435a0f0c0b8a6d0a2efb32d4ec5a85f023c2b79d39512040355b/scipy-1.15.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79167bba085c31f38603e11a267d862957cbb3ce018d8b38f79ac043bc92d825", size = 35174018, upload-time = "2025-05-08T16:07:19.427Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/09/c5b6734a50ad4882432b6bb7c02baf757f5b2f256041da5df242e2d7e6b6/scipy-1.15.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9deabd6d547aee2c9a81dee6cc96c6d7e9a9b1953f74850c179f91fdc729cb7", size = 37269716, upload-time = "2025-05-08T16:07:25.712Z" },
+    { url = "https://files.pythonhosted.org/packages/77/0a/eac00ff741f23bcabd352731ed9b8995a0a60ef57f5fd788d611d43d69a1/scipy-1.15.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:dde4fc32993071ac0c7dd2d82569e544f0bdaff66269cb475e0f369adad13f11", size = 36872342, upload-time = "2025-05-08T16:07:31.468Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/54/4379be86dd74b6ad81551689107360d9a3e18f24d20767a2d5b9253a3f0a/scipy-1.15.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f77f853d584e72e874d87357ad70f44b437331507d1c311457bed8ed2b956126", size = 39670869, upload-time = "2025-05-08T16:07:38.002Z" },
+    { url = "https://files.pythonhosted.org/packages/87/2e/892ad2862ba54f084ffe8cc4a22667eaf9c2bcec6d2bff1d15713c6c0703/scipy-1.15.3-cp313-cp313-win_amd64.whl", hash = "sha256:b90ab29d0c37ec9bf55424c064312930ca5f4bde15ee8619ee44e69319aab163", size = 40988851, upload-time = "2025-05-08T16:08:33.671Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/e9/7a879c137f7e55b30d75d90ce3eb468197646bc7b443ac036ae3fe109055/scipy-1.15.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3ac07623267feb3ae308487c260ac684b32ea35fd81e12845039952f558047b8", size = 38863011, upload-time = "2025-05-08T16:07:44.039Z" },
+    { url = "https://files.pythonhosted.org/packages/51/d1/226a806bbd69f62ce5ef5f3ffadc35286e9fbc802f606a07eb83bf2359de/scipy-1.15.3-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:6487aa99c2a3d509a5227d9a5e889ff05830a06b2ce08ec30df6d79db5fcd5c5", size = 30266407, upload-time = "2025-05-08T16:07:49.891Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/9b/f32d1d6093ab9eeabbd839b0f7619c62e46cc4b7b6dbf05b6e615bbd4400/scipy-1.15.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:50f9e62461c95d933d5c5ef4a1f2ebf9a2b4e83b0db374cb3f1de104d935922e", size = 22540030, upload-time = "2025-05-08T16:07:54.121Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/29/c278f699b095c1a884f29fda126340fcc201461ee8bfea5c8bdb1c7c958b/scipy-1.15.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:14ed70039d182f411ffc74789a16df3835e05dc469b898233a245cdfd7f162cb", size = 25218709, upload-time = "2025-05-08T16:07:58.506Z" },
+    { url = "https://files.pythonhosted.org/packages/24/18/9e5374b617aba742a990581373cd6b68a2945d65cc588482749ef2e64467/scipy-1.15.3-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a769105537aa07a69468a0eefcd121be52006db61cdd8cac8a0e68980bbb723", size = 34809045, upload-time = "2025-05-08T16:08:03.929Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/fe/9c4361e7ba2927074360856db6135ef4904d505e9b3afbbcb073c4008328/scipy-1.15.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9db984639887e3dffb3928d118145ffe40eff2fa40cb241a306ec57c219ebbbb", size = 36703062, upload-time = "2025-05-08T16:08:09.558Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/8e/038ccfe29d272b30086b25a4960f757f97122cb2ec42e62b460d02fe98e9/scipy-1.15.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:40e54d5c7e7ebf1aa596c374c49fa3135f04648a0caabcb66c52884b943f02b4", size = 36393132, upload-time = "2025-05-08T16:08:15.34Z" },
+    { url = "https://files.pythonhosted.org/packages/10/7e/5c12285452970be5bdbe8352c619250b97ebf7917d7a9a9e96b8a8140f17/scipy-1.15.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5e721fed53187e71d0ccf382b6bf977644c533e506c4d33c3fb24de89f5c3ed5", size = 38979503, upload-time = "2025-05-08T16:08:21.513Z" },
+    { url = "https://files.pythonhosted.org/packages/81/06/0a5e5349474e1cbc5757975b21bd4fad0e72ebf138c5592f191646154e06/scipy-1.15.3-cp313-cp313t-win_amd64.whl", hash = "sha256:76ad1fb5f8752eabf0fa02e4cc0336b4e8f021e2d5f061ed37d6d264db35e3ca", size = 40308097, upload-time = "2025-05-08T16:08:27.627Z" },
+]
+
+[[package]]
+name = "scipy"
+version = "1.16.2"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+dependencies = [
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4c/3b/546a6f0bfe791bbb7f8d591613454d15097e53f906308ec6f7c1ce588e8e/scipy-1.16.2.tar.gz", hash = "sha256:af029b153d243a80afb6eabe40b0a07f8e35c9adc269c019f364ad747f826a6b", size = 30580599, upload-time = "2025-09-11T17:48:08.271Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/ef/37ed4b213d64b48422df92560af7300e10fe30b5d665dd79932baebee0c6/scipy-1.16.2-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:6ab88ea43a57da1af33292ebd04b417e8e2eaf9d5aa05700be8d6e1b6501cd92", size = 36619956, upload-time = "2025-09-11T17:39:20.5Z" },
+    { url = "https://files.pythonhosted.org/packages/85/ab/5c2eba89b9416961a982346a4d6a647d78c91ec96ab94ed522b3b6baf444/scipy-1.16.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:c95e96c7305c96ede73a7389f46ccd6c659c4da5ef1b2789466baeaed3622b6e", size = 28931117, upload-time = "2025-09-11T17:39:29.06Z" },
+    { url = "https://files.pythonhosted.org/packages/80/d1/eed51ab64d227fe60229a2d57fb60ca5898cfa50ba27d4f573e9e5f0b430/scipy-1.16.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:87eb178db04ece7c698220d523c170125dbffebb7af0345e66c3554f6f60c173", size = 20921997, upload-time = "2025-09-11T17:39:34.892Z" },
+    { url = "https://files.pythonhosted.org/packages/be/7c/33ea3e23bbadde96726edba6bf9111fb1969d14d9d477ffa202c67bec9da/scipy-1.16.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:4e409eac067dcee96a57fbcf424c13f428037827ec7ee3cb671ff525ca4fc34d", size = 23523374, upload-time = "2025-09-11T17:39:40.846Z" },
+    { url = "https://files.pythonhosted.org/packages/96/0b/7399dc96e1e3f9a05e258c98d716196a34f528eef2ec55aad651ed136d03/scipy-1.16.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e574be127bb760f0dad24ff6e217c80213d153058372362ccb9555a10fc5e8d2", size = 33583702, upload-time = "2025-09-11T17:39:49.011Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/bc/a5c75095089b96ea72c1bd37a4497c24b581ec73db4ef58ebee142ad2d14/scipy-1.16.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f5db5ba6188d698ba7abab982ad6973265b74bb40a1efe1821b58c87f73892b9", size = 35883427, upload-time = "2025-09-11T17:39:57.406Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/66/e25705ca3d2b87b97fe0a278a24b7f477b4023a926847935a1a71488a6a6/scipy-1.16.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ec6e74c4e884104ae006d34110677bfe0098203a3fec2f3faf349f4cb05165e3", size = 36212940, upload-time = "2025-09-11T17:40:06.013Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/fd/0bb911585e12f3abdd603d721d83fc1c7492835e1401a0e6d498d7822b4b/scipy-1.16.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:912f46667d2d3834bc3d57361f854226475f695eb08c08a904aadb1c936b6a88", size = 38865092, upload-time = "2025-09-11T17:40:15.143Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/73/c449a7d56ba6e6f874183759f8483cde21f900a8be117d67ffbb670c2958/scipy-1.16.2-cp311-cp311-win_amd64.whl", hash = "sha256:91e9e8a37befa5a69e9cacbe0bcb79ae5afb4a0b130fd6db6ee6cc0d491695fa", size = 38687626, upload-time = "2025-09-11T17:40:24.041Z" },
+    { url = "https://files.pythonhosted.org/packages/68/72/02f37316adf95307f5d9e579023c6899f89ff3a051fa079dbd6faafc48e5/scipy-1.16.2-cp311-cp311-win_arm64.whl", hash = "sha256:f3bf75a6dcecab62afde4d1f973f1692be013110cad5338007927db8da73249c", size = 25503506, upload-time = "2025-09-11T17:40:30.703Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/8d/6396e00db1282279a4ddd507c5f5e11f606812b608ee58517ce8abbf883f/scipy-1.16.2-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:89d6c100fa5c48472047632e06f0876b3c4931aac1f4291afc81a3644316bb0d", size = 36646259, upload-time = "2025-09-11T17:40:39.329Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/93/ea9edd7e193fceb8eef149804491890bde73fb169c896b61aa3e2d1e4e77/scipy-1.16.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:ca748936cd579d3f01928b30a17dc474550b01272d8046e3e1ee593f23620371", size = 28888976, upload-time = "2025-09-11T17:40:46.82Z" },
+    { url = "https://files.pythonhosted.org/packages/91/4d/281fddc3d80fd738ba86fd3aed9202331180b01e2c78eaae0642f22f7e83/scipy-1.16.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:fac4f8ce2ddb40e2e3d0f7ec36d2a1e7f92559a2471e59aec37bd8d9de01fec0", size = 20879905, upload-time = "2025-09-11T17:40:52.545Z" },
+    { url = "https://files.pythonhosted.org/packages/69/40/b33b74c84606fd301b2915f0062e45733c6ff5708d121dd0deaa8871e2d0/scipy-1.16.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:033570f1dcefd79547a88e18bccacff025c8c647a330381064f561d43b821232", size = 23553066, upload-time = "2025-09-11T17:40:59.014Z" },
+    { url = "https://files.pythonhosted.org/packages/55/a7/22c739e2f21a42cc8f16bc76b47cff4ed54fbe0962832c589591c2abec34/scipy-1.16.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ea3421209bf00c8a5ef2227de496601087d8f638a2363ee09af059bd70976dc1", size = 33336407, upload-time = "2025-09-11T17:41:06.796Z" },
+    { url = "https://files.pythonhosted.org/packages/53/11/a0160990b82999b45874dc60c0c183d3a3a969a563fffc476d5a9995c407/scipy-1.16.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f66bd07ba6f84cd4a380b41d1bf3c59ea488b590a2ff96744845163309ee8e2f", size = 35673281, upload-time = "2025-09-11T17:41:15.055Z" },
+    { url = "https://files.pythonhosted.org/packages/96/53/7ef48a4cfcf243c3d0f1643f5887c81f29fdf76911c4e49331828e19fc0a/scipy-1.16.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e9feab931bd2aea4a23388c962df6468af3d808ddf2d40f94a81c5dc38f32ef", size = 36004222, upload-time = "2025-09-11T17:41:23.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7f/71a69e0afd460049d41c65c630c919c537815277dfea214031005f474d78/scipy-1.16.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:03dfc75e52f72cf23ec2ced468645321407faad8f0fe7b1f5b49264adbc29cb1", size = 38664586, upload-time = "2025-09-11T17:41:31.021Z" },
+    { url = "https://files.pythonhosted.org/packages/34/95/20e02ca66fb495a95fba0642fd48e0c390d0ece9b9b14c6e931a60a12dea/scipy-1.16.2-cp312-cp312-win_amd64.whl", hash = "sha256:0ce54e07bbb394b417457409a64fd015be623f36e330ac49306433ffe04bc97e", size = 38550641, upload-time = "2025-09-11T17:41:36.61Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ad/13646b9beb0a95528ca46d52b7babafbe115017814a611f2065ee4e61d20/scipy-1.16.2-cp312-cp312-win_arm64.whl", hash = "sha256:2a8ffaa4ac0df81a0b94577b18ee079f13fecdb924df3328fc44a7dc5ac46851", size = 25456070, upload-time = "2025-09-11T17:41:41.3Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/27/c5b52f1ee81727a9fc457f5ac1e9bf3d6eab311805ea615c83c27ba06400/scipy-1.16.2-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:84f7bf944b43e20b8a894f5fe593976926744f6c185bacfcbdfbb62736b5cc70", size = 36604856, upload-time = "2025-09-11T17:41:47.695Z" },
+    { url = "https://files.pythonhosted.org/packages/32/a9/15c20d08e950b540184caa8ced675ba1128accb0e09c653780ba023a4110/scipy-1.16.2-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:5c39026d12edc826a1ef2ad35ad1e6d7f087f934bb868fc43fa3049c8b8508f9", size = 28864626, upload-time = "2025-09-11T17:41:52.642Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/fc/ea36098df653cca26062a627c1a94b0de659e97127c8491e18713ca0e3b9/scipy-1.16.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:e52729ffd45b68777c5319560014d6fd251294200625d9d70fd8626516fc49f5", size = 20855689, upload-time = "2025-09-11T17:41:57.886Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/6f/d0b53be55727f3e6d7c72687ec18ea6d0047cf95f1f77488b99a2bafaee1/scipy-1.16.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:024dd4a118cccec09ca3209b7e8e614931a6ffb804b2a601839499cb88bdf925", size = 23512151, upload-time = "2025-09-11T17:42:02.303Z" },
+    { url = "https://files.pythonhosted.org/packages/11/85/bf7dab56e5c4b1d3d8eef92ca8ede788418ad38a7dc3ff50262f00808760/scipy-1.16.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7a5dc7ee9c33019973a470556081b0fd3c9f4c44019191039f9769183141a4d9", size = 33329824, upload-time = "2025-09-11T17:42:07.549Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6a/1a927b14ddc7714111ea51f4e568203b2bb6ed59bdd036d62127c1a360c8/scipy-1.16.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c2275ff105e508942f99d4e3bc56b6ef5e4b3c0af970386ca56b777608ce95b7", size = 35681881, upload-time = "2025-09-11T17:42:13.255Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/5f/331148ea5780b4fcc7007a4a6a6ee0a0c1507a796365cc642d4d226e1c3a/scipy-1.16.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:af80196eaa84f033e48444d2e0786ec47d328ba00c71e4299b602235ffef9acb", size = 36006219, upload-time = "2025-09-11T17:42:18.765Z" },
+    { url = "https://files.pythonhosted.org/packages/46/3a/e991aa9d2aec723b4a8dcfbfc8365edec5d5e5f9f133888067f1cbb7dfc1/scipy-1.16.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9fb1eb735fe3d6ed1f89918224e3385fbf6f9e23757cacc35f9c78d3b712dd6e", size = 38682147, upload-time = "2025-09-11T17:42:25.177Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/57/0f38e396ad19e41b4c5db66130167eef8ee620a49bc7d0512e3bb67e0cab/scipy-1.16.2-cp313-cp313-win_amd64.whl", hash = "sha256:fda714cf45ba43c9d3bae8f2585c777f64e3f89a2e073b668b32ede412d8f52c", size = 38520766, upload-time = "2025-09-11T17:43:25.342Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/a5/85d3e867b6822d331e26c862a91375bb7746a0b458db5effa093d34cdb89/scipy-1.16.2-cp313-cp313-win_arm64.whl", hash = "sha256:2f5350da923ccfd0b00e07c3e5cfb316c1c0d6c1d864c07a72d092e9f20db104", size = 25451169, upload-time = "2025-09-11T17:43:30.198Z" },
+    { url = "https://files.pythonhosted.org/packages/09/d9/60679189bcebda55992d1a45498de6d080dcaf21ce0c8f24f888117e0c2d/scipy-1.16.2-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:53d8d2ee29b925344c13bda64ab51785f016b1b9617849dac10897f0701b20c1", size = 37012682, upload-time = "2025-09-11T17:42:30.677Z" },
+    { url = "https://files.pythonhosted.org/packages/83/be/a99d13ee4d3b7887a96f8c71361b9659ba4ef34da0338f14891e102a127f/scipy-1.16.2-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:9e05e33657efb4c6a9d23bd8300101536abd99c85cca82da0bffff8d8764d08a", size = 29389926, upload-time = "2025-09-11T17:42:35.845Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/0a/130164a4881cec6ca8c00faf3b57926f28ed429cd6001a673f83c7c2a579/scipy-1.16.2-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:7fe65b36036357003b3ef9d37547abeefaa353b237e989c21027b8ed62b12d4f", size = 21381152, upload-time = "2025-09-11T17:42:40.07Z" },
+    { url = "https://files.pythonhosted.org/packages/47/a6/503ffb0310ae77fba874e10cddfc4a1280bdcca1d13c3751b8c3c2996cf8/scipy-1.16.2-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:6406d2ac6d40b861cccf57f49592f9779071655e9f75cd4f977fa0bdd09cb2e4", size = 23914410, upload-time = "2025-09-11T17:42:44.313Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/c7/1147774bcea50d00c02600aadaa919facbd8537997a62496270133536ed6/scipy-1.16.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ff4dc42bd321991fbf611c23fc35912d690f731c9914bf3af8f417e64aca0f21", size = 33481880, upload-time = "2025-09-11T17:42:49.325Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/74/99d5415e4c3e46b2586f30cdbecb95e101c7192628a484a40dd0d163811a/scipy-1.16.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:654324826654d4d9133e10675325708fb954bc84dae6e9ad0a52e75c6b1a01d7", size = 35791425, upload-time = "2025-09-11T17:42:54.711Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/ee/a6559de7c1cc710e938c0355d9d4fbcd732dac4d0d131959d1f3b63eb29c/scipy-1.16.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:63870a84cd15c44e65220eaed2dac0e8f8b26bbb991456a033c1d9abfe8a94f8", size = 36178622, upload-time = "2025-09-11T17:43:00.375Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/7b/f127a5795d5ba8ece4e0dce7d4a9fb7cb9e4f4757137757d7a69ab7d4f1a/scipy-1.16.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:fa01f0f6a3050fa6a9771a95d5faccc8e2f5a92b4a2e5440a0fa7264a2398472", size = 38783985, upload-time = "2025-09-11T17:43:06.661Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/9f/bc81c1d1e033951eb5912cd3750cc005943afa3e65a725d2443a3b3c4347/scipy-1.16.2-cp313-cp313t-win_amd64.whl", hash = "sha256:116296e89fba96f76353a8579820c2512f6e55835d3fad7780fece04367de351", size = 38631367, upload-time = "2025-09-11T17:43:14.44Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/5e/2cc7555fd81d01814271412a1d59a289d25f8b63208a0a16c21069d55d3e/scipy-1.16.2-cp313-cp313t-win_arm64.whl", hash = "sha256:98e22834650be81d42982360382b43b17f7ba95e0e6993e2a4f5b9ad9283a94d", size = 25787992, upload-time = "2025-09-11T17:43:19.745Z" },
+]
+
+[[package]]
+name = "sentry-sdk"
+version = "2.42.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/31/04/ec8c1dd9250847303d98516e917978cb1c7083024770d86d657d2ccb5a70/sentry_sdk-2.42.1.tar.gz", hash = "sha256:8598cc6edcfe74cb8074ba6a7c15338cdee93d63d3eb9b9943b4b568354ad5b6", size = 354839, upload-time = "2025-10-20T12:38:40.45Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/cb/c21b96ff379923310b4fb2c06e8d560d801e24aeb300faa72a04776868fc/sentry_sdk-2.42.1-py2.py3-none-any.whl", hash = "sha256:f8716b50c927d3beb41bc88439dc6bcd872237b596df5b14613e2ade104aee02", size = 380952, upload-time = "2025-10-20T12:38:38.88Z" },
+]
+
+[[package]]
+name = "setuptools"
+version = "83.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", hash = "sha256:025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef", size = 1154254, upload-time = "2026-07-04T15:31:22.699Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", hash = "sha256:29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3", size = 1008090, upload-time = "2026-07-04T15:31:20.885Z" },
+]
+
+[[package]]
+name = "shapely"
+version = "2.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4d/bc/0989043118a27cccb4e906a46b7565ce36ca7b57f5a18b78f4f1b0f72d9d/shapely-2.1.2.tar.gz", hash = "sha256:2ed4ecb28320a433db18a5bf029986aa8afcfd740745e78847e330d5d94922a9", size = 315489, upload-time = "2025-09-24T13:51:41.432Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/05/89/c3548aa9b9812a5d143986764dededfa48d817714e947398bdda87c77a72/shapely-2.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7ae48c236c0324b4e139bea88a306a04ca630f49be66741b340729d380d8f52f", size = 1825959, upload-time = "2025-09-24T13:50:00.682Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/8a/7ebc947080442edd614ceebe0ce2cdbd00c25e832c240e1d1de61d0e6b38/shapely-2.1.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:eba6710407f1daa8e7602c347dfc94adc02205ec27ed956346190d66579eb9ea", size = 1629196, upload-time = "2025-09-24T13:50:03.447Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/86/c9c27881c20d00fc409e7e059de569d5ed0abfcec9c49548b124ebddea51/shapely-2.1.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ef4a456cc8b7b3d50ccec29642aa4aeda959e9da2fe9540a92754770d5f0cf1f", size = 2951065, upload-time = "2025-09-24T13:50:05.266Z" },
+    { url = "https://files.pythonhosted.org/packages/50/8a/0ab1f7433a2a85d9e9aea5b1fbb333f3b09b309e7817309250b4b7b2cc7a/shapely-2.1.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e38a190442aacc67ff9f75ce60aec04893041f16f97d242209106d502486a142", size = 3058666, upload-time = "2025-09-24T13:50:06.872Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/c6/5a30ffac9c4f3ffd5b7113a7f5299ccec4713acd5ee44039778a7698224e/shapely-2.1.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:40d784101f5d06a1fd30b55fc11ea58a61be23f930d934d86f19a180909908a4", size = 3966905, upload-time = "2025-09-24T13:50:09.417Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/72/e92f3035ba43e53959007f928315a68fbcf2eeb4e5ededb6f0dc7ff1ecc3/shapely-2.1.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f6f6cd5819c50d9bcf921882784586aab34a4bd53e7553e175dece6db513a6f0", size = 4129260, upload-time = "2025-09-24T13:50:11.183Z" },
+    { url = "https://files.pythonhosted.org/packages/42/24/605901b73a3d9f65fa958e63c9211f4be23d584da8a1a7487382fac7fdc5/shapely-2.1.2-cp310-cp310-win32.whl", hash = "sha256:fe9627c39c59e553c90f5bc3128252cb85dc3b3be8189710666d2f8bc3a5503e", size = 1544301, upload-time = "2025-09-24T13:50:12.521Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/89/6db795b8dd3919851856bd2ddd13ce434a748072f6fdee42ff30cbd3afa3/shapely-2.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:1d0bfb4b8f661b3b4ec3565fa36c340bfb1cda82087199711f86a88647d26b2f", size = 1722074, upload-time = "2025-09-24T13:50:13.909Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/8d/1ff672dea9ec6a7b5d422eb6d095ed886e2e523733329f75fdcb14ee1149/shapely-2.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:91121757b0a36c9aac3427a651a7e6567110a4a67c97edf04f8d55d4765f6618", size = 1820038, upload-time = "2025-09-24T13:50:15.628Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/ce/28fab8c772ce5db23a0d86bf0adaee0c4c79d5ad1db766055fa3dab442e2/shapely-2.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:16a9c722ba774cf50b5d4541242b4cce05aafd44a015290c82ba8a16931ff63d", size = 1626039, upload-time = "2025-09-24T13:50:16.881Z" },
+    { url = "https://files.pythonhosted.org/packages/70/8b/868b7e3f4982f5006e9395c1e12343c66a8155c0374fdc07c0e6a1ab547d/shapely-2.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cc4f7397459b12c0b196c9efe1f9d7e92463cbba142632b4cc6d8bbbbd3e2b09", size = 3001519, upload-time = "2025-09-24T13:50:18.606Z" },
+    { url = "https://files.pythonhosted.org/packages/13/02/58b0b8d9c17c93ab6340edd8b7308c0c5a5b81f94ce65705819b7416dba5/shapely-2.1.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:136ab87b17e733e22f0961504d05e77e7be8c9b5a8184f685b4a91a84efe3c26", size = 3110842, upload-time = "2025-09-24T13:50:21.77Z" },
+    { url = "https://files.pythonhosted.org/packages/af/61/8e389c97994d5f331dcffb25e2fa761aeedfb52b3ad9bcdd7b8671f4810a/shapely-2.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:16c5d0fc45d3aa0a69074979f4f1928ca2734fb2e0dde8af9611e134e46774e7", size = 4021316, upload-time = "2025-09-24T13:50:23.626Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/d4/9b2a9fe6039f9e42ccf2cb3e84f219fd8364b0c3b8e7bbc857b5fbe9c14c/shapely-2.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6ddc759f72b5b2b0f54a7e7cde44acef680a55019eb52ac63a7af2cf17cb9cd2", size = 4178586, upload-time = "2025-09-24T13:50:25.443Z" },
+    { url = "https://files.pythonhosted.org/packages/16/f6/9840f6963ed4decf76b08fd6d7fed14f8779fb7a62cb45c5617fa8ac6eab/shapely-2.1.2-cp311-cp311-win32.whl", hash = "sha256:2fa78b49485391224755a856ed3b3bd91c8455f6121fee0db0e71cefb07d0ef6", size = 1543961, upload-time = "2025-09-24T13:50:26.968Z" },
+    { url = "https://files.pythonhosted.org/packages/38/1e/3f8ea46353c2a33c1669eb7327f9665103aa3a8dfe7f2e4ef714c210b2c2/shapely-2.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:c64d5c97b2f47e3cd9b712eaced3b061f2b71234b3fc263e0fcf7d889c6559dc", size = 1722856, upload-time = "2025-09-24T13:50:28.497Z" },
+    { url = "https://files.pythonhosted.org/packages/24/c0/f3b6453cf2dfa99adc0ba6675f9aaff9e526d2224cbd7ff9c1a879238693/shapely-2.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fe2533caae6a91a543dec62e8360fe86ffcdc42a7c55f9dfd0128a977a896b94", size = 1833550, upload-time = "2025-09-24T13:50:30.019Z" },
+    { url = "https://files.pythonhosted.org/packages/86/07/59dee0bc4b913b7ab59ab1086225baca5b8f19865e6101db9ebb7243e132/shapely-2.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ba4d1333cc0bc94381d6d4308d2e4e008e0bd128bdcff5573199742ee3634359", size = 1643556, upload-time = "2025-09-24T13:50:32.291Z" },
+    { url = "https://files.pythonhosted.org/packages/26/29/a5397e75b435b9895cd53e165083faed5d12fd9626eadec15a83a2411f0f/shapely-2.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0bd308103340030feef6c111d3eb98d50dc13feea33affc8a6f9fa549e9458a3", size = 2988308, upload-time = "2025-09-24T13:50:33.862Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/37/e781683abac55dde9771e086b790e554811a71ed0b2b8a1e789b7430dd44/shapely-2.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1e7d4d7ad262a48bb44277ca12c7c78cb1b0f56b32c10734ec9a1d30c0b0c54b", size = 3099844, upload-time = "2025-09-24T13:50:35.459Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/f3/9876b64d4a5a321b9dc482c92bb6f061f2fa42131cba643c699f39317cb9/shapely-2.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e9eddfe513096a71896441a7c37db72da0687b34752c4e193577a145c71736fc", size = 3988842, upload-time = "2025-09-24T13:50:37.478Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/a0/704c7292f7014c7e74ec84eddb7b109e1fbae74a16deae9c1504b1d15565/shapely-2.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:980c777c612514c0cf99bc8a9de6d286f5e186dcaf9091252fcd444e5638193d", size = 4152714, upload-time = "2025-09-24T13:50:39.9Z" },
+    { url = "https://files.pythonhosted.org/packages/53/46/319c9dc788884ad0785242543cdffac0e6530e4d0deb6c4862bc4143dcf3/shapely-2.1.2-cp312-cp312-win32.whl", hash = "sha256:9111274b88e4d7b54a95218e243282709b330ef52b7b86bc6aaf4f805306f454", size = 1542745, upload-time = "2025-09-24T13:50:41.414Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/bf/cb6c1c505cb31e818e900b9312d514f381fbfa5c4363edfce0fcc4f8c1a4/shapely-2.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:743044b4cfb34f9a67205cee9279feaf60ba7d02e69febc2afc609047cb49179", size = 1722861, upload-time = "2025-09-24T13:50:43.35Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/90/98ef257c23c46425dc4d1d31005ad7c8d649fe423a38b917db02c30f1f5a/shapely-2.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b510dda1a3672d6879beb319bc7c5fd302c6c354584690973c838f46ec3e0fa8", size = 1832644, upload-time = "2025-09-24T13:50:44.886Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/ab/0bee5a830d209adcd3a01f2d4b70e587cdd9fd7380d5198c064091005af8/shapely-2.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8cff473e81017594d20ec55d86b54bc635544897e13a7cfc12e36909c5309a2a", size = 1642887, upload-time = "2025-09-24T13:50:46.735Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/5e/7d7f54ba960c13302584c73704d8c4d15404a51024631adb60b126a4ae88/shapely-2.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fe7b77dc63d707c09726b7908f575fc04ff1d1ad0f3fb92aec212396bc6cfe5e", size = 2970931, upload-time = "2025-09-24T13:50:48.374Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/a2/83fc37e2a58090e3d2ff79175a95493c664bcd0b653dd75cb9134645a4e5/shapely-2.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7ed1a5bbfb386ee8332713bf7508bc24e32d24b74fc9a7b9f8529a55db9f4ee6", size = 3082855, upload-time = "2025-09-24T13:50:50.037Z" },
+    { url = "https://files.pythonhosted.org/packages/44/2b/578faf235a5b09f16b5f02833c53822294d7f21b242f8e2d0cf03fb64321/shapely-2.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a84e0582858d841d54355246ddfcbd1fce3179f185da7470f41ce39d001ee1af", size = 3979960, upload-time = "2025-09-24T13:50:51.74Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/04/167f096386120f692cc4ca02f75a17b961858997a95e67a3cb6a7bbd6b53/shapely-2.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dc3487447a43d42adcdf52d7ac73804f2312cbfa5d433a7d2c506dcab0033dfd", size = 4142851, upload-time = "2025-09-24T13:50:53.49Z" },
+    { url = "https://files.pythonhosted.org/packages/48/74/fb402c5a6235d1c65a97348b48cdedb75fb19eca2b1d66d04969fc1c6091/shapely-2.1.2-cp313-cp313-win32.whl", hash = "sha256:9c3a3c648aedc9f99c09263b39f2d8252f199cb3ac154fadc173283d7d111350", size = 1541890, upload-time = "2025-09-24T13:50:55.337Z" },
+    { url = "https://files.pythonhosted.org/packages/41/47/3647fe7ad990af60ad98b889657a976042c9988c2807cf322a9d6685f462/shapely-2.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:ca2591bff6645c216695bdf1614fca9c82ea1144d4a7591a466fef64f28f0715", size = 1722151, upload-time = "2025-09-24T13:50:57.153Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/49/63953754faa51ffe7d8189bfbe9ca34def29f8c0e34c67cbe2a2795f269d/shapely-2.1.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2d93d23bdd2ed9dc157b46bc2f19b7da143ca8714464249bef6771c679d5ff40", size = 1834130, upload-time = "2025-09-24T13:50:58.49Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/ee/dce001c1984052970ff60eb4727164892fb2d08052c575042a47f5a9e88f/shapely-2.1.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:01d0d304b25634d60bd7cf291828119ab55a3bab87dc4af1e44b07fb225f188b", size = 1642802, upload-time = "2025-09-24T13:50:59.871Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e7/fc4e9a19929522877fa602f705706b96e78376afb7fad09cad5b9af1553c/shapely-2.1.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8d8382dd120d64b03698b7298b89611a6ea6f55ada9d39942838b79c9bc89801", size = 3018460, upload-time = "2025-09-24T13:51:02.08Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/18/7519a25db21847b525696883ddc8e6a0ecaa36159ea88e0fef11466384d0/shapely-2.1.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:19efa3611eef966e776183e338b2d7ea43569ae99ab34f8d17c2c054d3205cc0", size = 3095223, upload-time = "2025-09-24T13:51:04.472Z" },
+    { url = "https://files.pythonhosted.org/packages/48/de/b59a620b1f3a129c3fecc2737104a0a7e04e79335bd3b0a1f1609744cf17/shapely-2.1.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:346ec0c1a0fcd32f57f00e4134d1200e14bf3f5ae12af87ba83ca275c502498c", size = 4030760, upload-time = "2025-09-24T13:51:06.455Z" },
+    { url = "https://files.pythonhosted.org/packages/96/b3/c6655ee7232b417562bae192ae0d3ceaadb1cc0ffc2088a2ddf415456cc2/shapely-2.1.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6305993a35989391bd3476ee538a5c9a845861462327efe00dd11a5c8c709a99", size = 4170078, upload-time = "2025-09-24T13:51:08.584Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/8e/605c76808d73503c9333af8f6cbe7e1354d2d238bda5f88eea36bfe0f42a/shapely-2.1.2-cp313-cp313t-win32.whl", hash = "sha256:c8876673449f3401f278c86eb33224c5764582f72b653a415d0e6672fde887bf", size = 1559178, upload-time = "2025-09-24T13:51:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/36/f7/d317eb232352a1f1444d11002d477e54514a4a6045536d49d0c59783c0da/shapely-2.1.2-cp313-cp313t-win_amd64.whl", hash = "sha256:4a44bc62a10d84c11a7a3d7c1c4fe857f7477c3506e24c9062da0db0ae0c449c", size = 1739756, upload-time = "2025-09-24T13:51:12.105Z" },
+]
+
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
+[[package]]
+name = "smmap"
+version = "5.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/44/cd/a040c4b3119bbe532e5b0732286f805445375489fceaec1f48306068ee3b/smmap-5.0.2.tar.gz", hash = "sha256:26ea65a03958fa0c8a1c7e8c7a58fdc77221b8910f6be2131affade476898ad5", size = 22329, upload-time = "2025-01-02T07:14:40.909Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/be/d09147ad1ec7934636ad912901c5fd7667e1c858e19d355237db0d0cd5e4/smmap-5.0.2-py3-none-any.whl", hash = "sha256:b30115f0def7d7531d22a0fb6502488d879e75b260a9db4d0819cfb25403af5e", size = 24303, upload-time = "2025-01-02T07:14:38.724Z" },
+]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
+]
+
+[[package]]
+name = "snowballstemmer"
+version = "3.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/75/a7/9810d872919697c9d01295633f5d574fb416d47e535f258272ca1f01f447/snowballstemmer-3.0.1.tar.gz", hash = "sha256:6d5eeeec8e9f84d4d56b847692bacf79bc2c8e90c7f80ca4444ff8b6f2e52895", size = 105575, upload-time = "2025-05-09T16:34:51.843Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c8/78/3565d011c61f5a43488987ee32b6f3f656e7f107ac2782dd57bdd7d91d9a/snowballstemmer-3.0.1-py3-none-any.whl", hash = "sha256:6cd7b3897da8d6c9ffb968a6781fa6532dce9c3618a4b127d920dab764a19064", size = 103274, upload-time = "2025-05-09T16:34:50.371Z" },
+]
+
+[[package]]
+name = "soupsieve"
+version = "2.9.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d9/38/e12680bbe6b4f8f3d17adcaf38d26850aa756c85cf4a80e79fc12a018fe8/soupsieve-2.9.1.tar.gz", hash = "sha256:c33e6605bbc71dd628b00c632d58ae607c22bade247e52553928f83bbb75b4ba", size = 122261, upload-time = "2026-07-21T16:57:17.452Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/2c/437fe806897c2d6cfdc3ee43a18da8bf8e568530a4ae9bac781541ca9896/soupsieve-2.9.1-py3-none-any.whl", hash = "sha256:4f4477399246b7a0c720a88ca2454b11cd6bb9ae4c9d170140786e916776c14c", size = 37404, upload-time = "2026-07-21T16:57:16.421Z" },
+]
+
+[[package]]
+name = "sphinx"
+version = "8.1.3"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+dependencies = [
+    { name = "alabaster", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "babel", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "colorama", marker = "(python_full_version < '3.11' and sys_platform == 'win32') or (python_full_version >= '3.11' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform != 'win32' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "docutils", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "imagesize", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "jinja2", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "packaging", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "pygments", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "requests", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "snowballstemmer", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinxcontrib-applehelp", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinxcontrib-devhelp", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinxcontrib-htmlhelp", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinxcontrib-jsmath", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinxcontrib-qthelp", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinxcontrib-serializinghtml", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "tomli", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/be0b61178fe2cdcb67e2a92fc9ebb488e3c51c4f74a36a7824c0adf23425/sphinx-8.1.3.tar.gz", hash = "sha256:43c1911eecb0d3e161ad78611bc905d1ad0e523e4ddc202a58a821773dc4c927", size = 8184611, upload-time = "2024-10-13T20:27:13.93Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/26/60/1ddff83a56d33aaf6f10ec8ce84b4c007d9368b21008876fceda7e7381ef/sphinx-8.1.3-py3-none-any.whl", hash = "sha256:09719015511837b76bf6e03e42eb7595ac8c2e41eeb9c29c5b755c6b677992a2", size = 3487125, upload-time = "2024-10-13T20:27:10.448Z" },
+]
+
+[[package]]
+name = "sphinx"
+version = "8.2.3"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+dependencies = [
+    { name = "alabaster", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "babel", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "colorama", marker = "(python_full_version >= '3.11' and sys_platform == 'win32') or (python_full_version < '3.11' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform != 'win32' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "docutils", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "imagesize", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "jinja2", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "packaging", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "pygments", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "requests", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "roman-numerals-py", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "snowballstemmer", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinxcontrib-applehelp", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinxcontrib-devhelp", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinxcontrib-htmlhelp", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinxcontrib-jsmath", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinxcontrib-qthelp", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinxcontrib-serializinghtml", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/38/ad/4360e50ed56cb483667b8e6dadf2d3fda62359593faabbe749a27c4eaca6/sphinx-8.2.3.tar.gz", hash = "sha256:398ad29dee7f63a75888314e9424d40f52ce5a6a87ae88e7071e80af296ec348", size = 8321876, upload-time = "2025-03-02T22:31:59.658Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/31/53/136e9eca6e0b9dc0e1962e2c908fbea2e5ac000c2a2fbd9a35797958c48b/sphinx-8.2.3-py3-none-any.whl", hash = "sha256:4405915165f13521d875a8c29c8970800a0141c14cc5416a38feca4ea5d9b9c3", size = 3589741, upload-time = "2025-03-02T22:31:56.836Z" },
+]
+
+[[package]]
+name = "sphinx-autobuild"
+version = "2024.10.3"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+dependencies = [
+    { name = "colorama", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "starlette", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "uvicorn", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "watchfiles", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "websockets", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a5/2c/155e1de2c1ba96a72e5dba152c509a8b41e047ee5c2def9e9f0d812f8be7/sphinx_autobuild-2024.10.3.tar.gz", hash = "sha256:248150f8f333e825107b6d4b86113ab28fa51750e5f9ae63b59dc339be951fb1", size = 14023, upload-time = "2024-10-02T23:15:30.172Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/c0/eba125db38c84d3c74717008fd3cb5000b68cd7e2cbafd1349c6a38c3d3b/sphinx_autobuild-2024.10.3-py3-none-any.whl", hash = "sha256:158e16c36f9d633e613c9aaf81c19b0fc458ca78b112533b20dafcda430d60fa", size = 11908, upload-time = "2024-10-02T23:15:28.739Z" },
+]
+
+[[package]]
+name = "sphinx-autobuild"
+version = "2025.8.25"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+dependencies = [
+    { name = "colorama", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "starlette", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "uvicorn", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "watchfiles", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "websockets", marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e0/3c/a59a3a453d4133777f7ed2e83c80b7dc817d43c74b74298ca0af869662ad/sphinx_autobuild-2025.8.25.tar.gz", hash = "sha256:9cf5aab32853c8c31af572e4fecdc09c997e2b8be5a07daf2a389e270e85b213", size = 15200, upload-time = "2025-08-25T18:44:55.436Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/20/56411b52f917696995f5ad27d2ea7e9492c84a043c5b49a3a3173573cd93/sphinx_autobuild-2025.8.25-py3-none-any.whl", hash = "sha256:b750ac7d5a18603e4665294323fd20f6dcc0a984117026d1986704fa68f0379a", size = 12535, upload-time = "2025-08-25T18:44:54.164Z" },
+]
+
+[[package]]
+name = "sphinx-autodoc-typehints"
+version = "3.0.1"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+dependencies = [
+    { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/26/f0/43c6a5ff3e7b08a8c3b32f81b859f1b518ccc31e45f22e2b41ced38be7b9/sphinx_autodoc_typehints-3.0.1.tar.gz", hash = "sha256:b9b40dd15dee54f6f810c924f863f9cf1c54f9f3265c495140ea01be7f44fa55", size = 36282, upload-time = "2025-01-16T18:25:30.958Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3c/dc/dc46c5c7c566b7ec5e8f860f9c89533bf03c0e6aadc96fb9b337867e4460/sphinx_autodoc_typehints-3.0.1-py3-none-any.whl", hash = "sha256:4b64b676a14b5b79cefb6628a6dc8070e320d4963e8ff640a2f3e9390ae9045a", size = 20245, upload-time = "2025-01-16T18:25:27.394Z" },
+]
+
+[[package]]
+name = "sphinx-autodoc-typehints"
+version = "3.5.2"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+dependencies = [
+    { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/34/4f/4fd5583678bb7dc8afa69e9b309e6a99ee8d79ad3a4728f4e52fd7cb37c7/sphinx_autodoc_typehints-3.5.2.tar.gz", hash = "sha256:5fcd4a3eb7aa89424c1e2e32bedca66edc38367569c9169a80f4b3e934171fdb", size = 37839, upload-time = "2025-10-16T00:50:15.743Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/05/f2/9657c98a66973b7c35bfd48ba65d1922860de9598fbb535cd96e3f58a908/sphinx_autodoc_typehints-3.5.2-py3-none-any.whl", hash = "sha256:0accd043619f53c86705958e323b419e41667917045ac9215d7be1b493648d8c", size = 21184, upload-time = "2025-10-16T00:50:13.973Z" },
+]
+
+[[package]]
+name = "sphinx-book-theme"
+version = "1.1.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydata-sphinx-theme" },
+    { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/45/19/d002ed96bdc7738c15847c730e1e88282d738263deac705d5713b4d8fa94/sphinx_book_theme-1.1.4.tar.gz", hash = "sha256:73efe28af871d0a89bd05856d300e61edce0d5b2fbb7984e84454be0fedfe9ed", size = 439188, upload-time = "2025-02-20T16:32:32.581Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/51/9e/c41d68be04eef5b6202b468e0f90faf0c469f3a03353f2a218fd78279710/sphinx_book_theme-1.1.4-py3-none-any.whl", hash = "sha256:843b3f5c8684640f4a2d01abd298beb66452d1b2394cd9ef5be5ebd5640ea0e1", size = 433952, upload-time = "2025-02-20T16:32:31.009Z" },
+]
+
+[[package]]
+name = "sphinx-copybutton"
+version = "0.5.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fc/2b/a964715e7f5295f77509e59309959f4125122d648f86b4fe7d70ca1d882c/sphinx-copybutton-0.5.2.tar.gz", hash = "sha256:4cf17c82fb9646d1bc9ca92ac280813a3b605d8c421225fd9913154103ee1fbd", size = 23039, upload-time = "2023-04-14T08:10:22.998Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/48/1ea60e74949eecb12cdd6ac43987f9fd331156388dcc2319b45e2ebb81bf/sphinx_copybutton-0.5.2-py3-none-any.whl", hash = "sha256:fb543fd386d917746c9a2c50360c7905b605726b9355cd26e9974857afeae06e", size = 13343, upload-time = "2023-04-14T08:10:20.844Z" },
+]
+
+[[package]]
+name = "sphinx-design"
+version = "0.6.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2b/69/b34e0cb5336f09c6866d53b4a19d76c227cdec1bbc7ac4de63ca7d58c9c7/sphinx_design-0.6.1.tar.gz", hash = "sha256:b44eea3719386d04d765c1a8257caca2b3e6f8421d7b3a5e742c0fd45f84e632", size = 2193689, upload-time = "2024-08-02T13:48:44.277Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c6/43/65c0acbd8cc6f50195a3a1fc195c404988b15c67090e73c7a41a9f57d6bd/sphinx_design-0.6.1-py3-none-any.whl", hash = "sha256:b11f37db1a802a183d61b159d9a202314d4d2fe29c163437001324fe2f19549c", size = 2215338, upload-time = "2024-08-02T13:48:42.106Z" },
+]
+
+[[package]]
+name = "sphinx-icon"
+version = "0.2.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyyaml" },
+    { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/52/ab/710717754aae8c598a9813f4268b5a63f05ef722635df9a98cb407ba89c7/sphinx-icon-0.2.2.tar.gz", hash = "sha256:d4361e96dbfe64d60481f2386f4986cb2e23716a968b130ceca01c25dcd63534", size = 949050, upload-time = "2023-03-14T13:25:42.175Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/59/c6/4ae8d43a77ee30e4bad8dc691510aa413af0e75f403bcc4cb41eb3642fd2/sphinx_icon-0.2.2-py3-none-any.whl", hash = "sha256:a985bf81077d0a79a7c166c16b6252f1e89bb3ad188ed89326a21bb334521105", size = 955793, upload-time = "2023-03-14T13:25:40.303Z" },
+]
+
+[[package]]
+name = "sphinx-multiversion"
+version = "0.2.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9a/10/25231164a97a9016bdc73a3530af8f4a6846bdc564af1460af2ff3e59a50/sphinx-multiversion-0.2.4.tar.gz", hash = "sha256:5cd1ca9ecb5eed63cb8d6ce5e9c438ca13af4fa98e7eb6f376be541dd4990bcb", size = 7024, upload-time = "2020-08-12T15:48:20.566Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/19/51/203bb30b3ce76373237288e92cb71fb66f80ee380473f36bfe8a9d299c5d/sphinx_multiversion-0.2.4-py2.py3-none-any.whl", hash = "sha256:5c38d5ce785a335d8c8d768b46509bd66bfb9c6252b93b700ca8c05317f207d6", size = 9597, upload-time = "2024-10-03T21:45:52.754Z" },
+    { url = "https://files.pythonhosted.org/packages/05/ad/4989e6be165805694e93d09bc57425aa1368273b7de4fe3083fe4310803a/sphinx_multiversion-0.2.4-py3-none-any.whl", hash = "sha256:dec29f2a5890ad68157a790112edc0eb63140e70f9df0a363743c6258fbeb478", size = 9642, upload-time = "2020-08-12T15:48:19.649Z" },
+]
+
+[[package]]
+name = "sphinx-tabs"
+version = "3.4.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "docutils" },
+    { name = "pygments" },
+    { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6a/53/a9a91995cb365e589f413b77fc75f1c0e9b4ac61bfa8da52a779ad855cc0/sphinx-tabs-3.4.7.tar.gz", hash = "sha256:991ad4a424ff54119799ba1491701aa8130dd43509474aef45a81c42d889784d", size = 15891, upload-time = "2024-10-08T13:37:27.887Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6b/c6/f47505b564b918a3ba60c1e99232d4942c4a7e44ecaae603e829e3d05dae/sphinx_tabs-3.4.7-py3-none-any.whl", hash = "sha256:c12d7a36fd413b369e9e9967a0a4015781b71a9c393575419834f19204bd1915", size = 9727, upload-time = "2024-10-08T13:37:26.192Z" },
+]
+
+[[package]]
+name = "sphinxcontrib-applehelp"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/6e/b837e84a1a704953c62ef8776d45c3e8d759876b4a84fe14eba2859106fe/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1", size = 20053, upload-time = "2024-07-29T01:09:00.465Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", size = 119300, upload-time = "2024-07-29T01:08:58.99Z" },
+]
+
+[[package]]
+name = "sphinxcontrib-bibtex"
+version = "2.6.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "docutils" },
+    { name = "pybtex" },
+    { name = "pybtex-docutils" },
+    { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/de/83/1488c9879f2fa3c2cbd6f666c7a3a42a1fa9e08462bec73281fa6c092cba/sphinxcontrib_bibtex-2.6.5.tar.gz", hash = "sha256:9b3224dd6fece9268ebd8c905dc0a83ff2f6c54148a9235fe70e9d1e9ff149c0", size = 118462, upload-time = "2025-06-27T10:40:14.061Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/a0/3a612da94f828f26cabb247817393e79472c32b12c49222bf85fb6d7b6c8/sphinxcontrib_bibtex-2.6.5-py3-none-any.whl", hash = "sha256:455ea4509642ea0b28ede3721550273626f85af65af01f161bfd8e19dc1edd7d", size = 40410, upload-time = "2025-06-27T10:40:12.274Z" },
+]
+
+[[package]]
+name = "sphinxcontrib-devhelp"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/d2/5beee64d3e4e747f316bae86b55943f51e82bb86ecd325883ef65741e7da/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad", size = 12967, upload-time = "2024-07-29T01:09:23.417Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", size = 82530, upload-time = "2024-07-29T01:09:21.945Z" },
+]
+
+[[package]]
+name = "sphinxcontrib-htmlhelp"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/93/983afd9aa001e5201eab16b5a444ed5b9b0a7a010541e0ddfbbfd0b2470c/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9", size = 22617, upload-time = "2024-07-29T01:09:37.889Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", size = 98705, upload-time = "2024-07-29T01:09:36.407Z" },
+]
+
+[[package]]
+name = "sphinxcontrib-jsmath"
+version = "1.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b2/e8/9ed3830aeed71f17c026a07a5097edcf44b692850ef215b161b8ad875729/sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8", size = 5787, upload-time = "2019-01-21T16:10:16.347Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", size = 5071, upload-time = "2019-01-21T16:10:14.333Z" },
+]
+
+[[package]]
+name = "sphinxcontrib-qthelp"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/68/bc/9104308fc285eb3e0b31b67688235db556cd5b0ef31d96f30e45f2e51cae/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab", size = 17165, upload-time = "2024-07-29T01:09:56.435Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", size = 88743, upload-time = "2024-07-29T01:09:54.885Z" },
+]
+
+[[package]]
+name = "sphinxcontrib-serializinghtml"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3b/44/6716b257b0aa6bfd51a1b31665d1c205fb12cb5ad56de752dfa15657de2f/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d", size = 16080, upload-time = "2024-07-29T01:10:09.332Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" },
+]
+
+[[package]]
+name = "sphinxemoji"
+version = "0.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ad/05/d531d8ce28eeb364e900dab98b8e236cf664a1b7f5fa93c212a5e87313aa/sphinxemoji-0.3.2.tar.gz", hash = "sha256:814da89a9a7603b7e4d85c487c7381656fa83632f20065e5ed782ab1dbbb5083", size = 45999, upload-time = "2025-12-15T12:01:56.885Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/12/ff5e52d884b218ee9807e25ebb779a544809d7f0da9e01326a6d273c0aa1/sphinxemoji-0.3.2-py3-none-any.whl", hash = "sha256:0fb07a95bca5960a3b312bc05b65b0c3040456414a076c363f4ecaf546c6e09e", size = 45454, upload-time = "2025-12-15T12:01:55.635Z" },
+]
+
+[[package]]
+name = "stack-data"
+version = "0.6.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "asttokens" },
+    { name = "executing" },
+    { name = "pure-eval" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" },
+]
+
+[[package]]
+name = "starlette"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/e3/7c1dc7381d9f8ab7d854328ebfa884e62cb3f3d8549ddfd37c7814f42afa/starlette-1.3.1.tar.gz", hash = "sha256:05d0213193f2fbaae60e2ecb593b4add4262ad4e46536b54abe36f11a71724e0", size = 2703240, upload-time = "2026-06-12T09:23:11.602Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/bb/2799cc2ede3ed41131f8975621e7213dfc7ef4acbbaadfa440f32500c370/starlette-1.3.1-py3-none-any.whl", hash = "sha256:c7372aae11c3c3f26a42df7bd626cec2f47d03483d261d369516a615a53714c6", size = 73632, upload-time = "2026-06-12T09:23:10.017Z" },
+]
+
+[[package]]
+name = "svg-path"
+version = "7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/66/b9/649abbe870842c185b12920e937e9b95d4c2b18de50af98d2c140df3e179/svg_path-7.0.tar.gz", hash = "sha256:9037486957cb1dcf4375ef42206499a47c111b8ffcbac6e3e55f9d079d875bb0", size = 23552, upload-time = "2025-07-06T15:20:40.823Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/83/4f5b250220e1a5acd31345a5ec1c95a7769725d0d8135276f399f44062f8/svg_path-7.0-py2.py3-none-any.whl", hash = "sha256:447cb1e16a95acea2dd867fe737fa99cb75d587b4fc64dbee709a8dd6891ad9c", size = 18208, upload-time = "2025-07-06T15:20:39.59Z" },
+]
+
+[[package]]
+name = "sympy"
+version = "1.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mpmath" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" },
+]
+
+[[package]]
+name = "tensorboard"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "absl-py" },
+    { name = "grpcio" },
+    { name = "markdown" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "packaging" },
+    { name = "pillow" },
+    { name = "protobuf" },
+    { name = "setuptools" },
+    { name = "tensorboard-data-server" },
+    { name = "werkzeug" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9c/d9/a5db55f88f258ac669a92858b70a714bbbd5acd993820b41ec4a96a4d77f/tensorboard-2.20.0-py3-none-any.whl", hash = "sha256:9dc9f978cb84c0723acf9a345d96c184f0293d18f166bb8d59ee098e6cfaaba6", size = 5525680, upload-time = "2025-07-17T19:20:49.638Z" },
+]
+
+[[package]]
+name = "tensorboard-data-server"
+version = "0.7.2"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7a/13/e503968fefabd4c6b2650af21e110aa8466fe21432cd7c43a84577a89438/tensorboard_data_server-0.7.2-py3-none-any.whl", hash = "sha256:7e0610d205889588983836ec05dc098e80f97b7e7bbff7e994ebb78f578d0ddb", size = 2356, upload-time = "2023-10-23T21:23:32.16Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/85/dabeaf902892922777492e1d253bb7e1264cadce3cea932f7ff599e53fea/tensorboard_data_server-0.7.2-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:9fe5d24221b29625dbc7328b0436ca7fc1c23de4acf4d272f1180856e32f9f60", size = 4823598, upload-time = "2023-10-23T21:23:33.714Z" },
+    { url = "https://files.pythonhosted.org/packages/73/c6/825dab04195756cf8ff2e12698f22513b3db2f64925bdd41671bfb33aaa5/tensorboard_data_server-0.7.2-py3-none-manylinux_2_31_x86_64.whl", hash = "sha256:ef687163c24185ae9754ed5650eb5bc4d84ff257aabdc33f0cc6f74d8ba54530", size = 6590363, upload-time = "2023-10-23T21:23:35.583Z" },
+]
+
+[[package]]
+name = "tensordict"
+version = "0.10.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cloudpickle" },
+    { name = "importlib-metadata" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "orjson", marker = "python_full_version < '3.13' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "packaging" },
+    { name = "pyvers" },
+    { name = "torch", version = "2.9.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform == 'darwin' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128')" },
+    { name = "torch", version = "2.9.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "torch", version = "2.10.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/56/bc0fb0e9b6693ba9e4279f88e77a6066667eb797f39fdf71b00ec7009413/tensordict-0.10.0-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:12322c4dfe1bd1bb2b77c33daf307451ecaf7ab9cb36717be1b42c7be1ee7463", size = 799176, upload-time = "2025-09-08T10:07:06.373Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/bf/f6df12346301deb7d2c21e8932125e683be3ae2f8b1b837aa9d00eb3d2af/tensordict-0.10.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:feaee76553ab39a443b35460714cde4e934dbe57e66c5174a20e44cf235d1b12", size = 442875, upload-time = "2025-09-08T10:07:08.668Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/9e/9539bdcfedc3d5affed07111c8a7f4810eaefe39af6f1f5c17bc4a220d1d/tensordict-0.10.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:690a3e729eefa814fdf99bf3c86f7cf8ae1bf704a381cf498e78fc9887cd4c8a", size = 446099, upload-time = "2025-09-08T10:07:09.919Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/67/81562c97a31a8a25659273ac7bb75fe7e4d514a637e3cb5d93992c606ecf/tensordict-0.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:4d76481efaae8ef0ab4f1e9a8787c0379f3e9efaa5cf37a4b039eaa153e3e475", size = 490909, upload-time = "2025-09-08T10:07:11.088Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/c9/44d4106f288cef22962268b54ed2438afee32e4f8380f0ed91e7dacc9b80/tensordict-0.10.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:37af5d60593c2439d81c2dbb7d0caa0018c50a3063da18b1d4d8b7d7d0503ee0", size = 800435, upload-time = "2025-09-08T10:07:12.581Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/7f/46b81cd2bf98860a6e4313605eccd45d44c7490dfd60b2124534d7efbe6e/tensordict-0.10.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:369c0a2dd3cbd9d0bcf98cc389486295e683d262bb57d4a07733cd56d936f4b2", size = 444486, upload-time = "2025-09-08T10:07:13.826Z" },
+    { url = "https://files.pythonhosted.org/packages/41/c1/373677e2376c25f0b01ba46907fcae33268d371bcaae45026f6fed418b77/tensordict-0.10.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:bccb6a7d7f02a8c83ca41815943bfa284da7d28019ab4276135809bda5ba05a6", size = 447610, upload-time = "2025-09-08T10:07:15.304Z" },
+    { url = "https://files.pythonhosted.org/packages/37/24/acc1f329605d5e57f33650b7bb3bd5bb39b0ba0ad86b1d06c2282b668004/tensordict-0.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:07f691f73eaefa40cf285266318caac54c7527afcd149646ed3dc1af2fc45c9d", size = 493474, upload-time = "2025-09-08T10:07:16.866Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/89/2914b6d2796bdbe64ba8d42b568bf02c25673f187079e8795fc668c609fa/tensordict-0.10.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:f52321ddec5da5acb3b90785c68b4fd4cce805aab6eb700ec59352e9f9e6214f", size = 801519, upload-time = "2025-09-08T10:07:18.954Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/88/2c1bf6c1abdc4d0bfcbdda2d1a5b19c7a9540f67ff6d20fe08d328d78305/tensordict-0.10.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:6a6ba462cc4c04299eb3746e8994df4a625706e60e2dfb88cc5f9513b6cbad2f", size = 445427, upload-time = "2025-09-08T10:07:20.148Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/05/6e7d130c5e9af947fad25fb7d40a3aa2fd9ef9d37c9c7ddc94ba11853d23/tensordict-0.10.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:6f0a52524c7c46778bf250444f1cd508f055735667b8d596a1a7e2fb38824e8c", size = 449961, upload-time = "2025-09-08T10:07:21.977Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/40/877fd0453c9c79a14063ecd21102a23460d033e3760e83eae7fd6c09b3ef/tensordict-0.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:76e7c1d6604addd08e026141c3943fa15fbe36db537f9ff311af5d2caee25daf", size = 494502, upload-time = "2025-09-08T10:07:23.2Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/28/95cabf70c3e6a44476ff03649f847178603d713a3d754ddc9245416c48df/tensordict-0.10.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:7074663d59bb42586f7ee9859377299cac8882bd28cfb43800d56976b893db1a", size = 801382, upload-time = "2025-09-08T10:07:24.683Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/c4/bbee035a2330c856bb5437a368e8e696c7bf0929b2cbf413999305b5d055/tensordict-0.10.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:c3c9c16f6601b396155701b05ce40f328edae4a7d4d3069240fbee66a3645fc3", size = 445382, upload-time = "2025-09-08T10:07:26.266Z" },
+    { url = "https://files.pythonhosted.org/packages/64/70/7aabb69d9dc760e4053187631e2af793a449a5a352e94c0c739d091e66ef/tensordict-0.10.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:102776f9e3ea17bcc17fd45896f22c5b045fb61b6b502a1a6a6ff627eacb9b68", size = 449861, upload-time = "2025-09-08T10:07:27.477Z" },
+    { url = "https://files.pythonhosted.org/packages/44/f3/c108125d0c5bfd9ca17904b90f4f9c1a6cbcf831389e24e2bb5ac2f90019/tensordict-0.10.0-cp313-cp313-win_amd64.whl", hash = "sha256:61dd9a7cd6229d1d21b492f6d920312029447c183dd41abc05d3a3671bc089e6", size = 494476, upload-time = "2025-09-08T10:07:28.961Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/ed/5f25c5ffcd7a7d30d2672f1cd513622b6df6869392664b087cfe6e0bfdc1/tensordict-0.10.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:3ef1d115c907f82c6b2bd7c2f1fcabb1b5541d4a327f6e53a60c95c56dd3323d", size = 807091, upload-time = "2025-09-08T10:07:30.609Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/da/092ff3ee460a97892f9294871908fd2536b31f891fc9eb006527064c27ad/tensordict-0.10.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:3aeb85359ae11142f9c29cb55d4e46e516381d772271aeff001e3c310715d5fa", size = 446841, upload-time = "2025-09-08T10:07:31.788Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/2a/3a1f103cf0da8b01ef1dc5605cbc5a3242bf6cd6151797dd32b15eaef278/tensordict-0.10.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:194adb6cac77e8e4f32b4b10b6a373d3389133e58b6eef184c598908d7cadc93", size = 449578, upload-time = "2025-09-08T10:07:32.933Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/7a/d7eb7472e7134b7cc9557e061e27061c3b9e1942426462f8ce93d1a9f13e/tensordict-0.10.0-cp313-cp313t-win_amd64.whl", hash = "sha256:7e5ba5d9eb21d76f1fc8fd5b06453cc497b2283f2317cbb2cb1bd848a92f2e2a", size = 504441, upload-time = "2025-09-08T10:07:34.114Z" },
+]
+
+[[package]]
+name = "tomli"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/52/ed/3f73f72945444548f33eba9a87fc7a6e969915e7b1acc8260b30e1f76a2f/tomli-2.3.0.tar.gz", hash = "sha256:64be704a875d2a59753d80ee8a533c3fe183e3f06807ff7dc2232938ccb01549", size = 17392, upload-time = "2025-10-08T22:01:47.119Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/2e/299f62b401438d5fe1624119c723f5d877acc86a4c2492da405626665f12/tomli-2.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:88bd15eb972f3664f5ed4b57c1634a97153b4bac4479dcb6a495f41921eb7f45", size = 153236, upload-time = "2025-10-08T22:01:00.137Z" },
+    { url = "https://files.pythonhosted.org/packages/86/7f/d8fffe6a7aefdb61bced88fcb5e280cfd71e08939da5894161bd71bea022/tomli-2.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:883b1c0d6398a6a9d29b508c331fa56adbcdff647f6ace4dfca0f50e90dfd0ba", size = 148084, upload-time = "2025-10-08T22:01:01.63Z" },
+    { url = "https://files.pythonhosted.org/packages/47/5c/24935fb6a2ee63e86d80e4d3b58b222dafaf438c416752c8b58537c8b89a/tomli-2.3.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d1381caf13ab9f300e30dd8feadb3de072aeb86f1d34a8569453ff32a7dea4bf", size = 234832, upload-time = "2025-10-08T22:01:02.543Z" },
+    { url = "https://files.pythonhosted.org/packages/89/da/75dfd804fc11e6612846758a23f13271b76d577e299592b4371a4ca4cd09/tomli-2.3.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a0e285d2649b78c0d9027570d4da3425bdb49830a6156121360b3f8511ea3441", size = 242052, upload-time = "2025-10-08T22:01:03.836Z" },
+    { url = "https://files.pythonhosted.org/packages/70/8c/f48ac899f7b3ca7eb13af73bacbc93aec37f9c954df3c08ad96991c8c373/tomli-2.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a154a9ae14bfcf5d8917a59b51ffd5a3ac1fd149b71b47a3a104ca4edcfa845", size = 239555, upload-time = "2025-10-08T22:01:04.834Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/28/72f8afd73f1d0e7829bfc093f4cb98ce0a40ffc0cc997009ee1ed94ba705/tomli-2.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:74bf8464ff93e413514fefd2be591c3b0b23231a77f901db1eb30d6f712fc42c", size = 245128, upload-time = "2025-10-08T22:01:05.84Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/eb/a7679c8ac85208706d27436e8d421dfa39d4c914dcf5fa8083a9305f58d9/tomli-2.3.0-cp311-cp311-win32.whl", hash = "sha256:00b5f5d95bbfc7d12f91ad8c593a1659b6387b43f054104cda404be6bda62456", size = 96445, upload-time = "2025-10-08T22:01:06.896Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/fe/3d3420c4cb1ad9cb462fb52967080575f15898da97e21cb6f1361d505383/tomli-2.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:4dc4ce8483a5d429ab602f111a93a6ab1ed425eae3122032db7e9acf449451be", size = 107165, upload-time = "2025-10-08T22:01:08.107Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b7/40f36368fcabc518bb11c8f06379a0fd631985046c038aca08c6d6a43c6e/tomli-2.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d7d86942e56ded512a594786a5ba0a5e521d02529b3826e7761a05138341a2ac", size = 154891, upload-time = "2025-10-08T22:01:09.082Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/3f/d9dd692199e3b3aab2e4e4dd948abd0f790d9ded8cd10cbaae276a898434/tomli-2.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:73ee0b47d4dad1c5e996e3cd33b8a76a50167ae5f96a2607cbe8cc773506ab22", size = 148796, upload-time = "2025-10-08T22:01:10.266Z" },
+    { url = "https://files.pythonhosted.org/packages/60/83/59bff4996c2cf9f9387a0f5a3394629c7efa5ef16142076a23a90f1955fa/tomli-2.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:792262b94d5d0a466afb5bc63c7daa9d75520110971ee269152083270998316f", size = 242121, upload-time = "2025-10-08T22:01:11.332Z" },
+    { url = "https://files.pythonhosted.org/packages/45/e5/7c5119ff39de8693d6baab6c0b6dcb556d192c165596e9fc231ea1052041/tomli-2.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4f195fe57ecceac95a66a75ac24d9d5fbc98ef0962e09b2eddec5d39375aae52", size = 250070, upload-time = "2025-10-08T22:01:12.498Z" },
+    { url = "https://files.pythonhosted.org/packages/45/12/ad5126d3a278f27e6701abde51d342aa78d06e27ce2bb596a01f7709a5a2/tomli-2.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e31d432427dcbf4d86958c184b9bfd1e96b5b71f8eb17e6d02531f434fd335b8", size = 245859, upload-time = "2025-10-08T22:01:13.551Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/a1/4d6865da6a71c603cfe6ad0e6556c73c76548557a8d658f9e3b142df245f/tomli-2.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7b0882799624980785240ab732537fcfc372601015c00f7fc367c55308c186f6", size = 250296, upload-time = "2025-10-08T22:01:14.614Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/b7/a7a7042715d55c9ba6e8b196d65d2cb662578b4d8cd17d882d45322b0d78/tomli-2.3.0-cp312-cp312-win32.whl", hash = "sha256:ff72b71b5d10d22ecb084d345fc26f42b5143c5533db5e2eaba7d2d335358876", size = 97124, upload-time = "2025-10-08T22:01:15.629Z" },
+    { url = "https://files.pythonhosted.org/packages/06/1e/f22f100db15a68b520664eb3328fb0ae4e90530887928558112c8d1f4515/tomli-2.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:1cb4ed918939151a03f33d4242ccd0aa5f11b3547d0cf30f7c74a408a5b99878", size = 107698, upload-time = "2025-10-08T22:01:16.51Z" },
+    { url = "https://files.pythonhosted.org/packages/89/48/06ee6eabe4fdd9ecd48bf488f4ac783844fd777f547b8d1b61c11939974e/tomli-2.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5192f562738228945d7b13d4930baffda67b69425a7f0da96d360b0a3888136b", size = 154819, upload-time = "2025-10-08T22:01:17.964Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/01/88793757d54d8937015c75dcdfb673c65471945f6be98e6a0410fba167ed/tomli-2.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:be71c93a63d738597996be9528f4abe628d1adf5e6eb11607bc8fe1a510b5dae", size = 148766, upload-time = "2025-10-08T22:01:18.959Z" },
+    { url = "https://files.pythonhosted.org/packages/42/17/5e2c956f0144b812e7e107f94f1cc54af734eb17b5191c0bbfb72de5e93e/tomli-2.3.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4665508bcbac83a31ff8ab08f424b665200c0e1e645d2bd9ab3d3e557b6185b", size = 240771, upload-time = "2025-10-08T22:01:20.106Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/f4/0fbd014909748706c01d16824eadb0307115f9562a15cbb012cd9b3512c5/tomli-2.3.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4021923f97266babc6ccab9f5068642a0095faa0a51a246a6a02fccbb3514eaf", size = 248586, upload-time = "2025-10-08T22:01:21.164Z" },
+    { url = "https://files.pythonhosted.org/packages/30/77/fed85e114bde5e81ecf9bc5da0cc69f2914b38f4708c80ae67d0c10180c5/tomli-2.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4ea38c40145a357d513bffad0ed869f13c1773716cf71ccaa83b0fa0cc4e42f", size = 244792, upload-time = "2025-10-08T22:01:22.417Z" },
+    { url = "https://files.pythonhosted.org/packages/55/92/afed3d497f7c186dc71e6ee6d4fcb0acfa5f7d0a1a2878f8beae379ae0cc/tomli-2.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ad805ea85eda330dbad64c7ea7a4556259665bdf9d2672f5dccc740eb9d3ca05", size = 248909, upload-time = "2025-10-08T22:01:23.859Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/84/ef50c51b5a9472e7265ce1ffc7f24cd4023d289e109f669bdb1553f6a7c2/tomli-2.3.0-cp313-cp313-win32.whl", hash = "sha256:97d5eec30149fd3294270e889b4234023f2c69747e555a27bd708828353ab606", size = 96946, upload-time = "2025-10-08T22:01:24.893Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/b7/718cd1da0884f281f95ccfa3a6cc572d30053cba64603f79d431d3c9b61b/tomli-2.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:0c95ca56fbe89e065c6ead5b593ee64b84a26fca063b5d71a1122bf26e533999", size = 107705, upload-time = "2025-10-08T22:01:26.153Z" },
+    { url = "https://files.pythonhosted.org/packages/77/b8/0135fadc89e73be292b473cb820b4f5a08197779206b33191e801feeae40/tomli-2.3.0-py3-none-any.whl", hash = "sha256:e95b1af3c5b07d9e643909b5abbec77cd9f1217e6d0bca72b0234736b9fb1f1b", size = 14408, upload-time = "2025-10-08T22:01:46.04Z" },
+]
+
+[[package]]
+name = "torch"
+version = "2.9.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+dependencies = [
+    { name = "filelock", marker = "sys_platform == 'darwin' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128')" },
+    { name = "fsspec", marker = "sys_platform == 'darwin' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128')" },
+    { name = "jinja2", marker = "sys_platform == 'darwin' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128')" },
+    { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "networkx", version = "3.5", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and sys_platform == 'darwin') or (python_full_version >= '3.11' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cublas-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cuda-cupti-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cuda-nvrtc-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cuda-runtime-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cudnn-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cufft-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cufile-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-curand-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cusolver-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cusparse-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cusparselt-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-nccl-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-nvshmem-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-nvtx-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "setuptools", marker = "(python_full_version >= '3.12' and sys_platform == 'darwin') or (python_full_version >= '3.12' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sympy", marker = "sys_platform == 'darwin' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128')" },
+    { name = "triton", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "typing-extensions", marker = "sys_platform == 'darwin' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128')" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bb/86/245c240d2138c17ed572c943c289056c2721abab70810d772c6bf5495b28/torch-2.9.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:030bbfe367379ae6a4ae4042b6c44da25383343b8b3c68abaa9c7231efbaf2dd", size = 104213554, upload-time = "2025-10-15T15:45:59.798Z" },
+    { url = "https://files.pythonhosted.org/packages/58/1d/fd1e88ae0948825efcab7dd66d12bec23f05d4d38ed81573c8d453c14c06/torch-2.9.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:51cb63902182a78e90886e8068befd8ea102af4b00e420263591a3d70c7d3c6c", size = 899795167, upload-time = "2025-10-15T15:47:12.695Z" },
+    { url = "https://files.pythonhosted.org/packages/63/5a/496197b45c14982bef4e079b24c61dc108e3ab0d0cc9718dba9f54f45a46/torch-2.9.0-cp310-cp310-win_amd64.whl", hash = "sha256:3f6aad4d2f0ee2248bac25339d74858ff846c3969b27d14ac235821f055af83d", size = 109310314, upload-time = "2025-10-15T15:46:16.633Z" },
+    { url = "https://files.pythonhosted.org/packages/58/b0/2b4e647b0fc706e88eb6c253d05511865578f5f67b55fad639bf3272a4a1/torch-2.9.0-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:413e1654c9203733138858780e184d9fc59442f0b3b209e16f39354eb893db9b", size = 74452019, upload-time = "2025-10-15T15:46:04.296Z" },
+    { url = "https://files.pythonhosted.org/packages/58/fe/334225e6330e672b36aef23d77451fa906ea12881570c08638a91331a212/torch-2.9.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:c596708b5105d0b199215acf0c9be7c1db5f1680d88eddadf4b75a299259a677", size = 104230578, upload-time = "2025-10-15T15:46:08.182Z" },
+    { url = "https://files.pythonhosted.org/packages/05/cc/49566caaa218872ec9a2912456f470ff92649894a4bc2e5274aa9ef87c4a/torch-2.9.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:51de31219c97c51cf4bf2be94d622e3deb5dcc526c6dc00e97c17eaec0fc1d67", size = 899815990, upload-time = "2025-10-15T15:48:03.336Z" },
+    { url = "https://files.pythonhosted.org/packages/74/25/e9ab21d5925b642d008f139d4a3c9664fc9ee1faafca22913c080cc4c0a5/torch-2.9.0-cp311-cp311-win_amd64.whl", hash = "sha256:dd515c70059afd95f48b8192733764c08ca37a1d19803af6401b5ecad7c8676e", size = 109313698, upload-time = "2025-10-15T15:46:12.425Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/b7/205ef3e94de636feffd64b28bb59a0dfac0771221201b9871acf9236f5ca/torch-2.9.0-cp311-none-macosx_11_0_arm64.whl", hash = "sha256:614a185e4986326d526a91210c8fc1397e76e8cfafa78baf6296a790e53a9eec", size = 74463678, upload-time = "2025-10-15T15:46:29.779Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/d3/3985739f3b8e88675127bf70f82b3a48ae083e39cda56305dbd90398fec0/torch-2.9.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:e5f7af1dc4c0a7c4a260c2534f41ddaf209714f7c89145e644c44712fbd6b642", size = 104107898, upload-time = "2025-10-15T15:46:20.883Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/4b/f4bb2e6c25d0272f798cd6d7a04ed315da76cec68c602d87040c7847287f/torch-2.9.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:01cff95ecd9a212ea2f141db28acccdceb6a4c54f64e6c51091146f5e2a772c6", size = 899738273, upload-time = "2025-10-15T15:50:04.188Z" },
+    { url = "https://files.pythonhosted.org/packages/66/11/c1c5ba6691cda6279087c35bd626536e4fd29521fe740abf5008377a9a02/torch-2.9.0-cp312-cp312-win_amd64.whl", hash = "sha256:4582b162f541651f0cb184d3e291c05c2f556c7117c64a9873e2ee158d40062b", size = 109280887, upload-time = "2025-10-15T15:46:26.228Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/5f/b85bd8c05312d71de9402bf5868d217c38827cfd09d8f8514e5be128a52b/torch-2.9.0-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:33f58e9a102a91259af289d50525c30323b5c9ae1d31322b6447c0814da68695", size = 74478983, upload-time = "2025-10-15T15:46:39.406Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/1c/90eb13833cdf4969ea9707586d7b57095c3b6e2b223a7256bf111689bcb8/torch-2.9.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:c30a17fc83eeab346913e237c64b15b5ba6407fff812f6c541e322e19bc9ea0e", size = 104111330, upload-time = "2025-10-15T15:46:35.238Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/21/2254c54b8d523592c25ef4434769aa23e29b1e6bf5f4c0ad9e27bf442927/torch-2.9.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:8f25033b8667b57857dfd01458fbf2a9e6a6df1f8def23aef0dc46292f6aa642", size = 899750243, upload-time = "2025-10-15T15:48:57.459Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/a5/5cb94fa4fd1e78223455c23c200f30f6dc10c6d4a2bcc8f6e7f2a2588370/torch-2.9.0-cp313-cp313-win_amd64.whl", hash = "sha256:d037f1b4ffd25013be4a7bf3651a0a910c68554956c7b2c92ebe87c76475dece", size = 109284513, upload-time = "2025-10-15T15:46:45.061Z" },
+    { url = "https://files.pythonhosted.org/packages/66/e8/fc414d8656250ee46120b44836ffbb3266343db424b3e18ca79ebbf69d4f/torch-2.9.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e4e5b5cba837a2a8d1a497ba9a58dae46fa392593eaa13b871c42f71847503a5", size = 74830362, upload-time = "2025-10-15T15:46:48.983Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/5f/9474c98fc5ae0cd04b9466035428cd360e6611a86b8352a0fc2fa504acdc/torch-2.9.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:64693568f5dc4dbd5f880a478b1cea0201cc6b510d91d1bc54fea86ac5d1a637", size = 104144940, upload-time = "2025-10-15T15:47:29.076Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/5a/8e0c1cf57830172c109d4bd6be2708cabeaf550983eee7029291322447a0/torch-2.9.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:f8ed31ddd7d10bfb3fbe0b9fe01b1243577f13d75e6f4a0839a283915ce3791e", size = 899744054, upload-time = "2025-10-15T15:48:29.864Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/28/82c28b30fcb4b7c9cdd995763d18bbb830d6521356712faebbad92ffa61d/torch-2.9.0-cp313-cp313t-win_amd64.whl", hash = "sha256:eff527d4e4846e6f70d2afd8058b73825761203d66576a7e04ea2ecfebcb4ab8", size = 109517546, upload-time = "2025-10-15T15:47:33.395Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/c3/a91f96ec74347fa5fd24453fa514bc61c61ecc79196fa760b012a1873d96/torch-2.9.0-cp313-none-macosx_11_0_arm64.whl", hash = "sha256:f8877779cf56d1ce431a7636703bdb13307f5960bb1af49716d8b179225e0e6a", size = 74480732, upload-time = "2025-10-15T15:47:38.002Z" },
+]
+
+[[package]]
+name = "torch"
+version = "2.9.0+cu128"
+source = { registry = "https://download.pytorch.org/whl/cu128" }
+resolution-markers = [
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+]
+dependencies = [
+    { name = "filelock", marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "fsspec", marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "jinja2", marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and sys_platform != 'darwin' and extra == 'extra-5-mjlab-cu128') or (python_full_version >= '3.11' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform == 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "networkx", version = "3.5", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and sys_platform != 'darwin' and extra == 'extra-5-mjlab-cu128') or (python_full_version < '3.11' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform == 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cublas-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cuda-cupti-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cuda-nvrtc-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cuda-runtime-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cudnn-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cufft-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cufile-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-curand-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cusolver-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cusparse-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-cusparselt-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-nccl-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-nvjitlink-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-nvshmem-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "nvidia-nvtx-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "setuptools", marker = "(python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-5-mjlab-cu128') or (python_full_version < '3.12' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform == 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sympy", marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "triton", marker = "(sys_platform == 'linux' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "typing-extensions", marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+wheels = [
+    { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.9.0%2Bcu128-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:edadd510a59951323ca24a53b8fe55d179b9a90237f0f55aae07f8ebc07dd052", upload-time = "2025-10-14T17:28:03Z" },
+    { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.9.0%2Bcu128-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:816540286fce245a8af3904a194a83af9c9292ad7452eb79160b7a3b1cefb7e3", upload-time = "2025-10-14T17:28:05Z" },
+    { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.9.0%2Bcu128-cp310-cp310-win_amd64.whl", hash = "sha256:397bfff20d46d22692726ca3450f9194a687244fce8fc01b755bf29d715485ee", upload-time = "2025-10-14T17:28:10Z" },
+    { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.9.0%2Bcu128-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:6848715fc906574eb2c0975f56771663344eef7b9a717816b50dede616a3d4fb", upload-time = "2025-10-14T17:28:16Z" },
+    { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.9.0%2Bcu128-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:e97c264478c9fc48f91832749d960f1e349aeb214224ebe65fb09435dd64c59a", upload-time = "2025-10-14T17:28:26Z" },
+    { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.9.0%2Bcu128-cp311-cp311-win_amd64.whl", hash = "sha256:dc6f6c6e7d7eed20c687fc189754a6ea6bf2da9c64eff59fd6753b80ed4bca05", upload-time = "2025-10-14T17:28:28Z" },
+    { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.9.0%2Bcu128-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:e1765625084e320f1eb2f4eb5fd9d14d39d08d7a1880c10a307ce5de20831d27", upload-time = "2025-10-14T17:28:29Z" },
+    { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.9.0%2Bcu128-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:87c62d3b95f1a2270bd116dbd47dc515c0b2035076fbb4a03b4365ea289e89c4", upload-time = "2025-10-14T17:28:41Z" },
+    { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.9.0%2Bcu128-cp312-cp312-win_amd64.whl", hash = "sha256:c97dc47a1f64745d439dd9471a96d216b728d528011029b4f9ae780e985529e0", upload-time = "2025-10-14T17:28:47Z" },
+    { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.9.0%2Bcu128-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:4d76f71345af47f022c7fa55edd0c1810d01af89dcb9edcfdfafe3d2a0f7a6b8", upload-time = "2025-10-14T17:28:50Z" },
+    { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.9.0%2Bcu128-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:97def0087f8ef171b9002ea500baffdd440c7bdd559c23c38bbf8781b67e9364", upload-time = "2025-10-14T17:29:01Z" },
+    { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.9.0%2Bcu128-cp313-cp313-win_amd64.whl", hash = "sha256:9cba9f0fa2e1b70fffdcec1235a1bb727cbff7e7b118ba111b2b7f984b7087e2", upload-time = "2025-10-14T17:29:02Z" },
+    { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.9.0%2Bcu128-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:dacbfc19608e60f78975c47d605c7d39b81afdf1983e93e94c17f60646b131e0", upload-time = "2025-10-14T17:29:13Z" },
+    { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.9.0%2Bcu128-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:8ce575fb71b878f5016df0a8a438c7c28f7f4be270af4119b5ad9ab62b0e470a", upload-time = "2025-10-14T17:29:21Z" },
+    { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.9.0%2Bcu128-cp313-cp313t-win_amd64.whl", hash = "sha256:26effd07b9ee31c2db8988860317ba74361967bb4f9228af5a56907215cc27b5", upload-time = "2025-10-14T17:29:26Z" },
+]
+
+[[package]]
+name = "torch"
+version = "2.10.0+cpu"
+source = { registry = "https://download.pytorch.org/whl/cpu" }
+resolution-markers = [
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+]
+dependencies = [
+    { name = "filelock", marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "fsspec", marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "jinja2", marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu') or (python_full_version >= '3.11' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform == 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "networkx", version = "3.5", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu') or (python_full_version < '3.11' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform == 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "setuptools", marker = "(python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu') or (python_full_version < '3.12' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform == 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "sympy", marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "typing-extensions", marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+wheels = [
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp310-cp310-linux_aarch64.whl", hash = "sha256:31ae44836c8b9bbd1a3943d29c7c7457709ddf7c6173aa34aefe9d2203e4c405", upload-time = "2026-01-23T15:10:02Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp310-cp310-linux_s390x.whl", hash = "sha256:beadc2a6a1785b09a46daad378de91ef274b8d3eea7af0bc2d017d97f115afdf", upload-time = "2026-01-23T15:10:03Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:d63ee6a80982fd73fe44bb70d97d2976e010312ff6db81d7bfb9167b06dd45b9", upload-time = "2026-01-23T15:10:05Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a280ffaea7b9c828e0c1b9b3bd502d9b6a649dc9416997b69b84544bd469f215", upload-time = "2026-01-23T15:10:07Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp310-cp310-win_amd64.whl", hash = "sha256:6c6f0df770144907092a0d067048d96ed4f278a6c840376d2ff0e27e7579b925", upload-time = "2026-01-23T15:10:09Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp311-cp311-linux_aarch64.whl", hash = "sha256:ce5c113d1f55f8c1f5af05047a24e50d11d293e0cbbb5bf7a75c6c761edd6eaa", upload-time = "2026-01-23T15:10:11Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp311-cp311-linux_s390x.whl", hash = "sha256:0e286fcf6ce0cc7b204396c9b4ea0d375f1f0c3e752f68ce3d3aeb265511db8c", upload-time = "2026-01-23T15:10:12Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:1cfcb9b1558c6e52dffd0d4effce83b13c5ae5d97338164c372048c21f9cfccb", upload-time = "2026-01-23T15:10:15Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:b7cb1ec66cefb90fd7b676eac72cfda3b8d4e4d0cacd7a531963bc2e0a9710ab", upload-time = "2026-01-23T15:10:15Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp311-cp311-win_amd64.whl", hash = "sha256:17a09465bab2aab8f0f273410297133d8d8fb6dd84dccbd252ca4a4f3a111847", upload-time = "2026-01-23T15:10:19Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp311-cp311-win_arm64.whl", hash = "sha256:c35c0de592941d4944698dbfa87271ab85d3370eca3b694943a2ab307ac34b3f", upload-time = "2026-01-23T15:10:20Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp312-cp312-linux_aarch64.whl", hash = "sha256:8de5a36371b775e2d4881ed12cc7f2de400b1ad3d728aa74a281f649f87c9b8c", upload-time = "2026-01-23T15:10:22Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp312-cp312-linux_s390x.whl", hash = "sha256:9accc30b56cb6756d4a9d04fcb8ebc0bb68c7d55c1ed31a8657397d316d31596", upload-time = "2026-01-23T15:10:24Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:179451716487f8cb09b56459667fa1f5c4c0946c1e75fbeae77cfc40a5768d87", upload-time = "2026-01-23T15:10:25Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:ee40b8a4b4b2cf0670c6fd4f35a7ef23871af956fecb238fbf5da15a72650b1d", upload-time = "2026-01-23T15:10:27Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp312-cp312-win_amd64.whl", hash = "sha256:21cb5436978ef47c823b7a813ff0f8c2892e266cfe0f1d944879b5fba81bf4e1", upload-time = "2026-01-23T15:10:30Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp312-cp312-win_arm64.whl", hash = "sha256:3eaa727e6a73affa61564d86b9d03191df45c8650d0666bd3d57c8597ef61e78", upload-time = "2026-01-23T15:10:31Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313-linux_aarch64.whl", hash = "sha256:fd215f3d0f681905c5b56b0630a3d666900a37fcc3ca5b937f95275c66f9fd9c", upload-time = "2026-01-23T15:10:34Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313-linux_s390x.whl", hash = "sha256:170a0623108055be5199370335cf9b41ba6875b3cb6f086db4aee583331a4899", upload-time = "2026-01-23T15:10:35Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:e51994492cdb76edce29da88de3672a3022f9ef0ffd90345436948d4992be2c7", upload-time = "2026-01-23T15:10:37Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:8d316e5bf121f1eab1147e49ad0511a9d92e4c45cc357d1ab0bee440da71a095", upload-time = "2026-01-23T15:10:38Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313-win_amd64.whl", hash = "sha256:b719da5af01b59126ac13eefd6ba3dd12d002dc0e8e79b8b365e55267a8189d3", upload-time = "2026-01-23T15:10:41Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313-win_arm64.whl", hash = "sha256:b67d91326e4ed9eccbd6b7d84ed7ffa43f93103aa3f0b24145f3001f3b11b714", upload-time = "2026-01-23T15:10:42Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313t-linux_aarch64.whl", hash = "sha256:5af75e5f49de21b0bdf7672bc27139bd285f9e8dbcabe2d617a2eb656514ac36", upload-time = "2026-01-23T15:10:44Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313t-linux_s390x.whl", hash = "sha256:ba51ef01a510baf8fff576174f702c47e1aa54389a9f1fba323bb1a5003ff0bf", upload-time = "2026-01-23T15:10:48Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:0fedcb1a77e8f2aaf7bfd21591bf6d1e0b207473268c9be16b17cb7783253969", upload-time = "2026-01-23T15:10:48Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:106dd1930cb30a4a337366ba3f9b25318ebf940f51fd46f789281dd9e736bdc4", upload-time = "2026-01-23T15:10:50Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313t-win_amd64.whl", hash = "sha256:eb1bde1ce198f05c8770017de27e001d404499cf552aaaa014569eff56ca25c0", upload-time = "2026-01-23T15:10:50Z" },
+]
+
+[[package]]
+name = "torchrunx"
+version = "0.3.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cloudpickle" },
+    { name = "fabric" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "torch", version = "2.9.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform == 'darwin' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (extra != 'extra-5-mjlab-cpu' and extra != 'extra-5-mjlab-cu128')" },
+    { name = "torch", version = "2.9.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cu128') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "torch", version = "2.10.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "(sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu') or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/65/60/ce6ccaf618e56775905e75e3fe7f2c8adfb61916d2946e854850c1d19a0d/torchrunx-0.3.4.tar.gz", hash = "sha256:6f2333fa17f7ef1f43f6c65d2b008b8479b29d972a8ed209da613d830dffdc45", size = 41312, upload-time = "2025-11-19T02:36:13.54Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/0d/9f5e24043f2562fd4dc15d04614cb5f3b4a1ffe327cb040b9f95b03fa84d/torchrunx-0.3.4-py3-none-any.whl", hash = "sha256:a157ec139f5a0bdfaa5ece50d987ff0a3212a4657d791367f11fdd383ccdbd5b", size = 34172, upload-time = "2025-11-19T02:36:12.354Z" },
+]
+
+[[package]]
+name = "tqdm"
+version = "4.67.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737, upload-time = "2024-11-24T20:12:22.481Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload-time = "2024-11-24T20:12:19.698Z" },
+]
+
+[[package]]
+name = "traitlets"
+version = "5.14.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" },
+]
+
+[[package]]
+name = "trimesh"
+version = "4.8.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/be/17/9799bd734de0aa75332727b10ecf56e2c93efa70dfc7a2966bed33539ef5/trimesh-4.8.3.tar.gz", hash = "sha256:d2a1974efccb0737a1faac14d69740c644bb6738a99c790c1df752fe72c2a759", size = 831222, upload-time = "2025-09-26T20:07:59.595Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8e/bc/f36afd1ad03d09cd0d311be5951f2dd705a824f34dd871779d42c277d741/trimesh-4.8.3-py3-none-any.whl", hash = "sha256:f9f1622ecac5f3bed5b65d3a748bb536481f52cd4e4e120e0b637cabe6cf1542", size = 735464, upload-time = "2025-09-26T20:07:56.512Z" },
+]
+
+[package.optional-dependencies]
+easy = [
+    { name = "charset-normalizer" },
+    { name = "colorlog" },
+    { name = "embreex", marker = "platform_machine == 'x86_64' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "httpx" },
+    { name = "jsonschema" },
+    { name = "lxml" },
+    { name = "manifold3d" },
+    { name = "mapbox-earcut" },
+    { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "networkx", version = "3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "pillow" },
+    { name = "pycollada" },
+    { name = "rtree" },
+    { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "scipy", version = "1.16.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "shapely" },
+    { name = "svg-path" },
+    { name = "vhacdx" },
+    { name = "xxhash" },
+]
+
+[[package]]
+name = "triton"
+version = "3.5.0"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dd/22/507b6f58a35e05e84381630b2dc2a3cee1a7a2a7eaf4cba857c638a18a24/triton-3.5.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6f90de6a6566bb619b4c0adc9855729e1b1b5e26533fca1bf6206e96b6d277a3", size = 159827599, upload-time = "2025-10-15T19:15:43.87Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/eb/09e31d107a5d00eb281aa7e6635ca463e9bca86515944e399480eadb71f8/triton-3.5.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5d3b3d480debf24eaa739623c9a42446b0b77f95593d30eb1f64cd2278cc1f0", size = 170333110, upload-time = "2025-10-13T16:37:49.588Z" },
+    { url = "https://files.pythonhosted.org/packages/79/f9/b6f60f978397c616fd8dacca2305759fe4f80d397b20ef72534803244bd5/triton-3.5.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8457b22148defefdcb7fa8144b05ce211b9faefad650a1ce85b23df488d5549c", size = 159926731, upload-time = "2025-10-15T19:15:49.682Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/78/949a04391c21956c816523678f0e5fa308eb5b1e7622d88c4e4ef5fceca0/triton-3.5.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f34bfa21c5b3a203c0f0eab28dcc1e49bd1f67d22724e77fb6665a659200a4ec", size = 170433488, upload-time = "2025-10-13T16:37:57.132Z" },
+    { url = "https://files.pythonhosted.org/packages/87/9b/30988039e1e84df7554fba24e6a734d2d0e847af33cabdf9b532b3c51456/triton-3.5.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7da21fccceafc163e3a5e857abe34351ef76345af06cabf9637a914742671f0b", size = 159946647, upload-time = "2025-10-15T19:15:56.325Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/3a/e991574f3102147b642e49637e0281e9bb7c4ba254edb2bab78247c85e01/triton-3.5.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c9e71db82261c4ffa3921cd050cd5faa18322d2d405c30eb56084afaff3b0833", size = 170476535, upload-time = "2025-10-13T16:38:05.18Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/85/e37f1197acb04c8f3d83851d23d5d6ed5060ef74580668b112e23fdfa203/triton-3.5.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:188da5b81fa2f8322c27fec1627703eac24cb9bb7ab0dfbe9925973bc1b070d3", size = 159958970, upload-time = "2025-10-15T19:16:01.717Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/29/10728de8a6e932e517c10773486b8e99f85d1b1d9dd87d9a9616e1fef4a1/triton-3.5.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e6bb9aa5519c084a333acdba443789e50012a4b851cd486c54f0b8dc2a8d3a12", size = 170487289, upload-time = "2025-10-13T16:38:11.662Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/1d/38258f05010ac17a7b058c022911c9cae6526e149b7397134a048cf5a6c2/triton-3.5.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:03127d9b33aaf979c856676b394bc059ec1d68cb6da68ae03f62dd8ad77a04ae", size = 160073012, upload-time = "2025-10-15T19:16:07.477Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/38/db80e48b9220c9bce872b0f616ad0446cdf554a40b85c7865cbca99ab3c2/triton-3.5.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c83f2343e1a220a716c7b3ab9fccfcbe3ad4020d189549200e2d2e8d5868bed9", size = 170577179, upload-time = "2025-10-13T16:38:17.865Z" },
+]
+
+[[package]]
+name = "ty"
+version = "0.0.14"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/57/22c3d6bf95c2229120c49ffc2f0da8d9e8823755a1c3194da56e51f1cc31/ty-0.0.14.tar.gz", hash = "sha256:a691010565f59dd7f15cf324cdcd1d9065e010c77a04f887e1ea070ba34a7de2", size = 5036573, upload-time = "2026-01-27T00:57:31.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/cb/cc6d1d8de59beb17a41f9a614585f884ec2d95450306c173b3b7cc090d2e/ty-0.0.14-py3-none-linux_armv6l.whl", hash = "sha256:32cf2a7596e693094621d3ae568d7ee16707dce28c34d1762947874060fdddaa", size = 10034228, upload-time = "2026-01-27T00:57:53.133Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/96/dd42816a2075a8f31542296ae687483a8d047f86a6538dfba573223eaf9a/ty-0.0.14-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:f971bf9805f49ce8c0968ad53e29624d80b970b9eb597b7cbaba25d8a18ce9a2", size = 9939162, upload-time = "2026-01-27T00:57:43.857Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b4/73c4859004e0f0a9eead9ecb67021438b2e8e5fdd8d03e7f5aca77623992/ty-0.0.14-py3-none-macosx_11_0_arm64.whl", hash = "sha256:45448b9e4806423523268bc15e9208c4f3f2ead7c344f615549d2e2354d6e924", size = 9418661, upload-time = "2026-01-27T00:58:03.411Z" },
+    { url = "https://files.pythonhosted.org/packages/58/35/839c4551b94613db4afa20ee555dd4f33bfa7352d5da74c5fa416ffa0fd2/ty-0.0.14-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee94a9b747ff40114085206bdb3205a631ef19a4d3fb89e302a88754cbbae54c", size = 9837872, upload-time = "2026-01-27T00:57:23.718Z" },
+    { url = "https://files.pythonhosted.org/packages/41/2b/bbecf7e2faa20c04bebd35fc478668953ca50ee5847ce23e08acf20ea119/ty-0.0.14-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6756715a3c33182e9ab8ffca2bb314d3c99b9c410b171736e145773ee0ae41c3", size = 9848819, upload-time = "2026-01-27T00:57:58.501Z" },
+    { url = "https://files.pythonhosted.org/packages/be/60/3c0ba0f19c0f647ad9d2b5b5ac68c0f0b4dc899001bd53b3a7537fb247a2/ty-0.0.14-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:89d0038a2f698ba8b6fec5cf216a4e44e2f95e4a5095a8c0f57fe549f87087c2", size = 10324371, upload-time = "2026-01-27T00:57:29.291Z" },
+    { url = "https://files.pythonhosted.org/packages/24/32/99d0a0b37d0397b0a989ffc2682493286aa3bc252b24004a6714368c2c3d/ty-0.0.14-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2c64a83a2d669b77f50a4957039ca1450626fb474619f18f6f8a3eb885bf7544", size = 10865898, upload-time = "2026-01-27T00:57:33.542Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/88/30b583a9e0311bb474269cfa91db53350557ebec09002bfc3fb3fc364e8c/ty-0.0.14-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:242488bfb547ef080199f6fd81369ab9cb638a778bb161511d091ffd49c12129", size = 10555777, upload-time = "2026-01-27T00:58:05.853Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/a2/cb53fb6325dcf3d40f2b1d0457a25d55bfbae633c8e337bde8ec01a190eb/ty-0.0.14-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4790c3866f6c83a4f424fc7d09ebdb225c1f1131647ba8bdc6fcdc28f09ed0ff", size = 10412913, upload-time = "2026-01-27T00:57:38.834Z" },
+    { url = "https://files.pythonhosted.org/packages/42/8f/f2f5202d725ed1e6a4e5ffaa32b190a1fe70c0b1a2503d38515da4130b4c/ty-0.0.14-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:950f320437f96d4ea9a2332bbfb5b68f1c1acd269ebfa4c09b6970cc1565bd9d", size = 9837608, upload-time = "2026-01-27T00:57:55.898Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/ba/59a2a0521640c489dafa2c546ae1f8465f92956fede18660653cce73b4c5/ty-0.0.14-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:4a0ec3ee70d83887f86925bbc1c56f4628bd58a0f47f6f32ddfe04e1f05466df", size = 9884324, upload-time = "2026-01-27T00:57:46.786Z" },
+    { url = "https://files.pythonhosted.org/packages/03/95/8d2a49880f47b638743212f011088552ecc454dd7a665ddcbdabea25772a/ty-0.0.14-py3-none-musllinux_1_2_i686.whl", hash = "sha256:a1a4e6b6da0c58b34415955279eff754d6206b35af56a18bb70eb519d8d139ef", size = 10033537, upload-time = "2026-01-27T00:58:01.149Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/40/4523b36f2ce69f92ccf783855a9e0ebbbd0f0bb5cdce6211ee1737159ed3/ty-0.0.14-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:dc04384e874c5de4c5d743369c277c8aa73d1edea3c7fc646b2064b637db4db3", size = 10495910, upload-time = "2026-01-27T00:57:26.691Z" },
+    { url = "https://files.pythonhosted.org/packages/08/d5/655beb51224d1bfd4f9ddc0bb209659bfe71ff141bcf05c418ab670698f0/ty-0.0.14-py3-none-win32.whl", hash = "sha256:b20e22cf54c66b3e37e87377635da412d9a552c9bf4ad9fc449fed8b2e19dad2", size = 9507626, upload-time = "2026-01-27T00:57:41.43Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/d9/c569c9961760e20e0a4bc008eeb1415754564304fd53997a371b7cf3f864/ty-0.0.14-py3-none-win_amd64.whl", hash = "sha256:e312ff9475522d1a33186657fe74d1ec98e4a13e016d66f5758a452c90ff6409", size = 10437980, upload-time = "2026-01-27T00:57:36.422Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/0c/186829654f5bfd9a028f6648e9caeb11271960a61de97484627d24443f91/ty-0.0.14-py3-none-win_arm64.whl", hash = "sha256:b6facdbe9b740cb2c15293a1d178e22ffc600653646452632541d01c36d5e378", size = 9885831, upload-time = "2026-01-27T00:57:49.747Z" },
+]
+
+[[package]]
+name = "typeguard"
+version = "4.4.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c7/68/71c1a15b5f65f40e91b65da23b8224dad41349894535a97f63a52e462196/typeguard-4.4.4.tar.gz", hash = "sha256:3a7fd2dffb705d4d0efaed4306a704c89b9dee850b688f060a8b1615a79e5f74", size = 75203, upload-time = "2025-06-18T09:56:07.624Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/a9/e3aee762739c1d7528da1c3e06d518503f8b6c439c35549b53735ba52ead/typeguard-4.4.4-py3-none-any.whl", hash = "sha256:b5f562281b6bfa1f5492470464730ef001646128b180769880468bd84b68b09e", size = 34874, upload-time = "2025-06-18T09:56:05.999Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "tyro"
+version = "1.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "docstring-parser" },
+    { name = "typeguard" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cf/b5/6fbb72a695975f5bc2e2ca00b847d5af1e85e6a473427f9f5f2c3a8d4601/tyro-1.0.1.tar.gz", hash = "sha256:45f5ed511c75c7ce9b7c311861ae259fda4cd0f971fae494c7161108e2f9e0db", size = 442689, upload-time = "2025-12-12T01:10:27.442Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/27/28/d938acc053b55f61e1be85ee6c9d88ceac5fea5d386bbf44684b645d9898/tyro-1.0.1-py3-none-any.whl", hash = "sha256:86c178c1ae39cc8be9d03d3149de70374c0c5c8682c5f48758cd299145719bf7", size = 179598, upload-time = "2025-12-12T01:10:26.016Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c3/d1/8f3c683c9561a4e6689dd3b1d345c815f10f86acd044ee1fb9a4dcd0b8c5/uvicorn-0.40.0.tar.gz", hash = "sha256:839676675e87e73694518b5574fd0f24c9d97b46bea16df7b8c05ea1a51071ea", size = 81761, upload-time = "2025-12-21T14:16:22.45Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/d8/2083a1daa7439a66f3a48589a57d576aa117726762618f6bb09fe3798796/uvicorn-0.40.0-py3-none-any.whl", hash = "sha256:c6c8f55bc8bf13eb6fa9ff87ad62308bbbc33d0b67f84293151efe87e0d5f2ee", size = 68502, upload-time = "2025-12-21T14:16:21.041Z" },
+]
+
+[[package]]
+name = "vhacdx"
+version = "0.0.8.post2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/5c/28d1172a1e1e36246a71922b15de047e30f3eadbf9561ff08c11e89777a5/vhacdx-0.0.8.post2.tar.gz", hash = "sha256:aa27c5ef19ed4aba428fa9408dccc37f2b7a6bbfaddc48b06a8cea9faaf93156", size = 58117, upload-time = "2025-02-12T17:55:53.537Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ad/42/db21d1e5aceab79ddb239fbfda1768950fad05e0aa225fafcc932b238c47/vhacdx-0.0.8.post2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:338cc9b993ae5f38c63c5eb613245fa7e236b0aca31fbdc44e72cb62a9aabee4", size = 212780, upload-time = "2025-02-12T17:54:30.942Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/b9/41f860fd710eeeb6361490752d60dbf0fde855b553d4d6c87789ddd2bfc8/vhacdx-0.0.8.post2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5ecad8c60cffd30c2ba296c566e54891154c9a99c3cfe699183b7d5f3252672f", size = 201841, upload-time = "2025-02-12T17:54:33.095Z" },
+    { url = "https://files.pythonhosted.org/packages/85/95/bfae45c0e7d16f4eb2617949c5a11e83d3e8790660f04583cf9e51897a65/vhacdx-0.0.8.post2-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:76a53690aace64318602dfa870065611fd3295f65dfa20c2771b95025b5be436", size = 281739, upload-time = "2025-02-12T17:54:34.446Z" },
+    { url = "https://files.pythonhosted.org/packages/73/2a/cf7b6c6e74a1d5324043af92198dacfc37a9e7942484e4810ef07cefea7b/vhacdx-0.0.8.post2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:44af65f367db3266b533079c82ef0d704a337c36ee18138aab4409cea338434b", size = 263693, upload-time = "2025-02-12T17:54:36.591Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/cc/4af771491bdc81c570d4ebb1cf3bde025b2ce7b9dbf83628f7bb65546289/vhacdx-0.0.8.post2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:a5af24c5c1b8cf9081ef0fc84aa9ff90229d11e18b9d8e0a47151a1671772d5a", size = 1339365, upload-time = "2025-02-12T17:54:39.156Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/48/7649b6675d57660aa14abe3e1ad06c00cead26fac1071292c61122245243/vhacdx-0.0.8.post2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:11b5a4e88e06fb9d626495e913f4edd2b1e8842eb554d6cfa76cf9d4c316091e", size = 1228983, upload-time = "2025-02-12T17:54:41.562Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/fd/0fe52df47ed5d853df3647b8c38916d45419559d8fb04946c0ba1a18d98f/vhacdx-0.0.8.post2-cp310-cp310-win_amd64.whl", hash = "sha256:17a992604c81361f8f422dd5d81801056acdff07640e496f941887627634db12", size = 182900, upload-time = "2025-02-12T17:54:43.743Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/f3/ec52783c8a78e1bd05218714c80a0c32c1f4e0767039b5e006ae9933e03d/vhacdx-0.0.8.post2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5eaf69d112e7a50d14024b903db904fc200d166b958283b2c260bed4d39358df", size = 214178, upload-time = "2025-02-12T17:54:45.691Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/0c/717fe3ae34dac4a97ef2a3ea2e7cd3c29e786341c250f4967dc0384e3101/vhacdx-0.0.8.post2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:394abebe4dc744ccc7588211ee5893ca38c99919fe220f9d89b39d6df5b58fed", size = 203219, upload-time = "2025-02-12T17:54:47.622Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/79/21bd4816450cfc86f97a72e087d110d2473176a287f7060a555d633dbe5e/vhacdx-0.0.8.post2-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7990594a3ba321dc087b93bb3c2489ac7aae755d8d53a8d2567e159efc16aea4", size = 283074, upload-time = "2025-02-12T17:54:48.999Z" },
+    { url = "https://files.pythonhosted.org/packages/45/d8/5a9fe022626801d6eedaa55ad7806fa62721cd9425d1858ca23e22acfe29/vhacdx-0.0.8.post2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ba873341d94c98b4ccddd7700579892e23d461b8b494e08b15b15577298497a", size = 266118, upload-time = "2025-02-12T17:54:51.16Z" },
+    { url = "https://files.pythonhosted.org/packages/65/87/7edd736a8d9126cf9972b447a6a733e514f3b684f3476f194ca9af031ebc/vhacdx-0.0.8.post2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:423052e1dbadc92c61dd083534b6b8a3870efa8bf4149b9063bca2e2067d4e5e", size = 1340015, upload-time = "2025-02-12T17:54:53.236Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/f6/b6172ae45d1641f13ddf2a6514f2419a97cf839bc8a8a9c3bbd0c9bf68d0/vhacdx-0.0.8.post2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:87489b0aec7412c148e5ed9b48315d800f8d119bcd3ae092d75f1e53873cbe9d", size = 1230730, upload-time = "2025-02-12T17:54:55.896Z" },
+    { url = "https://files.pythonhosted.org/packages/80/2a/dce5c6d34f183b5c1e65a5b1a0fb09d13f6fa49a43b749daff50166312ec/vhacdx-0.0.8.post2-cp311-cp311-win_amd64.whl", hash = "sha256:1b89340eb36e45f802a8da67b4c1c46636a9a1ba99f87ac201d24b058936c4ad", size = 184079, upload-time = "2025-02-12T17:54:57.859Z" },
+    { url = "https://files.pythonhosted.org/packages/40/4a/f18c105ca4a3917178c4dd89f9f5d0a4c00c0181511170e2b6e4a3f0661a/vhacdx-0.0.8.post2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:674a439ffca148606749679eab6be8aa922564f4020e5107621104b74336ad82", size = 212638, upload-time = "2025-02-12T17:54:59.221Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/03/b7d0bf31aef5cedd0dc103014bd4c72478b2bff5164517a5ac63351ac65d/vhacdx-0.0.8.post2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:689722e9404dc1f9bd1ca7b014f9d365d827168117ef58b88240c8f2a07aa3b8", size = 202282, upload-time = "2025-02-12T17:55:01.154Z" },
+    { url = "https://files.pythonhosted.org/packages/50/20/26396f42c5019eb93718b3860d04c9985c7887b0a22c0f062965f1ea7f96/vhacdx-0.0.8.post2-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e98da63b5cb62fa0a428f90027ac15020e1ede0ac2d560fb3d8652318c7626c4", size = 282299, upload-time = "2025-02-12T17:55:03.273Z" },
+    { url = "https://files.pythonhosted.org/packages/37/66/40a09cfff237ad76ff22fad65bd1ed41c669e55a517b60c644271fc073d5/vhacdx-0.0.8.post2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e3495f73572fe695cf9c9983d4ed7b2ee457372bce1e41848d1c369edd08679", size = 265951, upload-time = "2025-02-12T17:55:04.57Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/20/8907b27b81cabeb6989bf766d9d63a4bbeffe9612ae28fd628a791b7bf99/vhacdx-0.0.8.post2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:199ab537c9a8f1dfd17fde784ee0dadb4b22488501cb7c92781ff5a92b5c2b54", size = 1339910, upload-time = "2025-02-12T17:55:08.126Z" },
+    { url = "https://files.pythonhosted.org/packages/85/b8/04fb06cda3c464780289f15f1a624f7094474641fead1358af3226606e37/vhacdx-0.0.8.post2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3aebbe99e5232fdf6b28e39bd2d147cbcc00423dac4dad2d0411de7c510b1e17", size = 1231069, upload-time = "2025-02-12T17:55:09.89Z" },
+    { url = "https://files.pythonhosted.org/packages/15/d2/413cdd9a33fdc664de45fe3229e5748b833a17ed6bd1b6247065fd1b5661/vhacdx-0.0.8.post2-cp312-cp312-win_amd64.whl", hash = "sha256:8a3b81f728424bb5b786c90289b969edc9308e6b11d6915c7bba1b8c86e670ef", size = 184296, upload-time = "2025-02-12T17:55:11.162Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/76/c44a3d51117743d89080e38dec40acd4d7679e1fad50602ad94d26dce680/vhacdx-0.0.8.post2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:736666f5430126864bb65439168b09466b57625eb904fad8e53cedf509380ddf", size = 212697, upload-time = "2025-02-12T17:55:12.378Z" },
+    { url = "https://files.pythonhosted.org/packages/79/78/bc4165736ae124dc35fa576aac07cb374b71df45b42d7d12419edd66305e/vhacdx-0.0.8.post2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fb4606cfe3b3ec41633fb775d0ea0e7d84bf376aeefa394faf9d53cf11b5e621", size = 202370, upload-time = "2025-02-12T17:55:13.688Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/23/2f75103af5fefe05f4e49cfa115accd41a7b01a14632f07e5590fb77cd0a/vhacdx-0.0.8.post2-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8ff97f752fc477f70c47ca27a77b9ab1cd8f3b136c963112a909c37f15eaab9b", size = 283227, upload-time = "2025-02-12T17:55:14.791Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/eb/dc560c827c481c6aa99c97c1da4bdd1ccadc07569264cc3bf8b54510376c/vhacdx-0.0.8.post2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d5a22eee55f5fdefce55dcbe7370419b77244e8c0c80fb836c661e75b8ac03e", size = 265770, upload-time = "2025-02-12T17:55:16.044Z" },
+    { url = "https://files.pythonhosted.org/packages/38/06/99e034f1db18222a3714940be025d753f02a8502381278472e560d419bb4/vhacdx-0.0.8.post2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:930f835e3c733f70bf8c049aa32c5ef8e4293dbc07a063bc3ad8f2ec32bb6560", size = 1340055, upload-time = "2025-02-12T17:55:17.329Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/24/a9bff6062e5341cedcd5af696b348b620a77f2dff95c503e4d984571ed1a/vhacdx-0.0.8.post2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4730df4bcd389109af298a5d80114113f82dc6f906e92eb9b6d9c453d1a2833b", size = 1231183, upload-time = "2025-02-12T17:55:18.706Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/f1/2aa1ea62195d34e9e8a5c24c429ff059db43a1e74760510bee39bf45ff2a/vhacdx-0.0.8.post2-cp313-cp313-win_amd64.whl", hash = "sha256:c4616c3b5aa2a457898367bf90931b8ef1f35cca21f404b5bd23ff9c11709faa", size = 184333, upload-time = "2025-02-12T17:55:21.411Z" },
+]
+
+[[package]]
+name = "virtualenv"
+version = "21.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "distlib" },
+    { name = "filelock" },
+    { name = "platformdirs" },
+    { name = "python-discovery" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/aa/92/58199fe10049f9703c2666e809c4f686c54ef0a68b0f6afccf518c0b1eb9/virtualenv-21.2.0.tar.gz", hash = "sha256:1720dc3a62ef5b443092e3f499228599045d7fea4c79199770499df8becf9098", size = 5840618, upload-time = "2026-03-09T17:24:38.013Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c6/59/7d02447a55b2e55755011a647479041bc92a82e143f96a8195cb33bd0a1c/virtualenv-21.2.0-py3-none-any.whl", hash = "sha256:1bd755b504931164a5a496d217c014d098426cddc79363ad66ac78125f9d908f", size = 5825084, upload-time = "2026-03-09T17:24:35.378Z" },
+]
+
+[[package]]
+name = "viser"
+version = "1.0.27"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "imageio" },
+    { name = "msgspec" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "requests" },
+    { name = "rich" },
+    { name = "tqdm" },
+    { name = "trimesh" },
+    { name = "typing-extensions" },
+    { name = "websockets" },
+    { name = "yourdfpy" },
+    { name = "zstandard" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fd/f5/48adb4e5e4234f48e96a1e7fc50cca6731280df0c279833e333963f9ea5c/viser-1.0.27.tar.gz", hash = "sha256:87e3239d6c1c2c003db93ac4072430ec790e336ffe7214781f035e54faebc0af", size = 4897986, upload-time = "2026-05-06T10:30:47.556Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7c/ad/8ae712579e294b4395fb39f7d65524b51fc7b731eacce26af096b7e59b61/viser-1.0.27-py3-none-any.whl", hash = "sha256:8da5b7934416e6e2d3a7ebcf39fc840f21030b51eb63231e8cfef457bfb49031", size = 4998748, upload-time = "2026-05-06T10:30:49.965Z" },
+]
+
+[[package]]
+name = "wandb"
+version = "0.22.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "gitpython" },
+    { name = "packaging" },
+    { name = "platformdirs" },
+    { name = "protobuf" },
+    { name = "pydantic" },
+    { name = "pyyaml" },
+    { name = "requests" },
+    { name = "sentry-sdk" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c1/d1/6b70f365ed86bd69debba8ad55dec8606fc21006e7ca703a5a091bd3b719/wandb-0.22.3.tar.gz", hash = "sha256:04468a8ab2769a46f5e384c9c4ada5da0dced005ca689a8424e4b8b5cb2a0291", size = 44337368, upload-time = "2025-10-28T23:59:10.275Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/23/02/87fb60f587ec249f784a40bd91c30de1b2b24d691ee72675d5b66c3d0728/wandb-0.22.3-py3-none-macosx_12_0_arm64.whl", hash = "sha256:81b3b6e405f38342b0a080898b7d00c5b9375432f5ba358942a09e65cdcfe781", size = 18758047, upload-time = "2025-10-28T23:58:46.56Z" },
+    { url = "https://files.pythonhosted.org/packages/26/88/64081740ef2b2efc7fbcb2139a07a849e42bcb09ae0c56ae50c41bd0ad63/wandb-0.22.3-py3-none-macosx_12_0_x86_64.whl", hash = "sha256:d29c16817cca6401b4919069ec7570c781eacb67dc0b1ff2e0096a9a59581720", size = 19798011, upload-time = "2025-10-28T23:58:49.718Z" },
+    { url = "https://files.pythonhosted.org/packages/19/72/c4f922b33dbb84d1c81ee045ff8791dd14e26d79e1e9bbafff964b7043e2/wandb-0.22.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bb955d73a4ba55df9adc61fafbabef5556784d33fc39c7b5c8165d2694ddeb3b", size = 18542713, upload-time = "2025-10-28T23:58:51.927Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/98/3ce5f6e2086d91b0c51b38ae7ff591109e7da2bb25fe1a12eec0cdbaa494/wandb-0.22.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:23f3ebe41a26506117a098fdfd2706ed0e50b37899bfbefe3a0628fcbd70c69d", size = 19984910, upload-time = "2025-10-28T23:58:54.641Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/57/e68cb38427b60490d6ddf1b992e6c7f36be83be1079d291ce87a8d347f48/wandb-0.22.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:2973462bed5d4a653b1a97cf9fc350673bb200fb356a2f4eba34beae9b87e0aa", size = 18581776, upload-time = "2025-10-28T23:58:56.975Z" },
+    { url = "https://files.pythonhosted.org/packages/66/6d/543f907ce0c6b6da13628b23d19ca7282c559fd73eb47b04977b9a61d0c6/wandb-0.22.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:c5c2bd18f95c1639863c527da0a5818ac6b0e5194f9c691426b265908ddd8b2c", size = 20078800, upload-time = "2025-10-28T23:58:59.217Z" },
+    { url = "https://files.pythonhosted.org/packages/da/91/1decaf1a6ac2017481c782e0fad7f90bc9ae4057f3d76d478cb6527f3dd3/wandb-0.22.3-py3-none-win32.whl", hash = "sha256:09ca1edfe0fd6dc30447d368acddb825668e60ee705c98594a6bbfd30d34d47e", size = 19160297, upload-time = "2025-10-28T23:59:01.536Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/ba/3b092634279994b0c79fe05220532822be09f3a353ae95c54e7142769db8/wandb-0.22.3-py3-none-win_amd64.whl", hash = "sha256:55403bf93872c9978433d101324f51e43e78c70c809bf6d06ca7b2760e39f497", size = 19160300, upload-time = "2025-10-28T23:59:04.06Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/80/4662fce9eebcc8c71f5083e9152ccaf7d43d4ca9c446e1422f9aa784a51c/wandb-0.22.3-py3-none-win_arm64.whl", hash = "sha256:49f66b05882abfa53816cc8d01b3c2435a89c5a090176802fa6928b5979d34d9", size = 17461959, upload-time = "2025-10-28T23:59:07.059Z" },
+]
+
+[[package]]
+name = "warp-lang"
+version = "1.14.0"
+source = { registry = "https://pypi.nvidia.com/" }
+resolution-markers = [
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform == 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'linux'",
+    "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux'",
+]
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and sys_platform != 'darwin') or (python_full_version >= '3.11' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform == 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.11.*' and sys_platform != 'darwin') or (python_full_version != '3.11.*' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform == 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.12' and sys_platform != 'darwin') or (python_full_version < '3.12' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform == 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+wheels = [
+    { url = "https://pypi.nvidia.com/warp-lang/warp_lang-1.14.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:12656050545cc77bf9b9b155399496c1a6279b5b6c59e407507d6858a2beb4a2" },
+    { url = "https://pypi.nvidia.com/warp-lang/warp_lang-1.14.0-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:70cd127d0e9109417099649fedf9d00f39f1307ccb7a6e9fb87661337868d7de" },
+    { url = "https://pypi.nvidia.com/warp-lang/warp_lang-1.14.0-py3-none-manylinux_2_34_aarch64.whl", hash = "sha256:f482787e8da9c9ef045601fde99095e16d604fbcc3cbb4a1e0cef0769388b316" },
+    { url = "https://pypi.nvidia.com/warp-lang/warp_lang-1.14.0-py3-none-win_amd64.whl", hash = "sha256:936b49ec78237f9760e58cbe9c46ee6f4244aefbd62071c4fa9fd3b313dfa878" },
+]
+
+[[package]]
+name = "warp-lang"
+version = "1.14.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.13' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version >= '3.13' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.12.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine != 'arm64' and platform_machine != 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 's390x' and sys_platform == 'darwin'",
+    "python_full_version < '3.11' and platform_machine == 'arm64' and sys_platform == 'darwin'",
+]
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version >= '3.11' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.11.*' and sys_platform == 'darwin') or (python_full_version != '3.11.*' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.12' and sys_platform == 'darwin') or (python_full_version < '3.12' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128') or (sys_platform != 'darwin' and extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/0f/28ba3c563a87adb85884fb59f5f281446f99a338c907e2b3f0b9f2f4a76c/warp_lang-1.14.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:12656050545cc77bf9b9b155399496c1a6279b5b6c59e407507d6858a2beb4a2", size = 24755239, upload-time = "2026-06-01T15:15:53.395Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/32/784829665b0cc6fadada337f103c811b7bf92a951a69c08f7e3cd6ab2580/warp_lang-1.14.0-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:70cd127d0e9109417099649fedf9d00f39f1307ccb7a6e9fb87661337868d7de", size = 138666257, upload-time = "2026-06-01T15:15:59.163Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/e1/1f882dfbf4b2528093722423b389984eb65433ac5ebe53f94a1f9a72c262/warp_lang-1.14.0-py3-none-manylinux_2_34_aarch64.whl", hash = "sha256:f482787e8da9c9ef045601fde99095e16d604fbcc3cbb4a1e0cef0769388b316", size = 140159761, upload-time = "2026-06-01T15:16:04.039Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/6a/f530a27d627c19302d40d100ad986b7d1722237866fe178a0c5233a4717e/warp_lang-1.14.0-py3-none-win_amd64.whl", hash = "sha256:936b49ec78237f9760e58cbe9c46ee6f4244aefbd62071c4fa9fd3b313dfa878", size = 121919902, upload-time = "2026-06-01T15:16:05.777Z" },
+]
+
+[[package]]
+name = "watchfiles"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440, upload-time = "2025-10-14T15:06:21.08Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a7/1a/206e8cf2dd86fddf939165a57b4df61607a1e0add2785f170a3f616b7d9f/watchfiles-1.1.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:eef58232d32daf2ac67f42dea51a2c80f0d03379075d44a587051e63cc2e368c", size = 407318, upload-time = "2025-10-14T15:04:18.753Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/0f/abaf5262b9c496b5dad4ed3c0e799cbecb1f8ea512ecb6ddd46646a9fca3/watchfiles-1.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:03fa0f5237118a0c5e496185cafa92878568b652a2e9a9382a5151b1a0380a43", size = 394478, upload-time = "2025-10-14T15:04:20.297Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/04/9cc0ba88697b34b755371f5ace8d3a4d9a15719c07bdc7bd13d7d8c6a341/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8ca65483439f9c791897f7db49202301deb6e15fe9f8fe2fed555bf986d10c31", size = 449894, upload-time = "2025-10-14T15:04:21.527Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/9c/eda4615863cd8621e89aed4df680d8c3ec3da6a4cf1da113c17decd87c7f/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f0ab1c1af0cb38e3f598244c17919fb1a84d1629cc08355b0074b6d7f53138ac", size = 459065, upload-time = "2025-10-14T15:04:22.795Z" },
+    { url = "https://files.pythonhosted.org/packages/84/13/f28b3f340157d03cbc8197629bc109d1098764abe1e60874622a0be5c112/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3bc570d6c01c206c46deb6e935a260be44f186a2f05179f52f7fcd2be086a94d", size = 488377, upload-time = "2025-10-14T15:04:24.138Z" },
+    { url = "https://files.pythonhosted.org/packages/86/93/cfa597fa9389e122488f7ffdbd6db505b3b915ca7435ecd7542e855898c2/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e84087b432b6ac94778de547e08611266f1f8ffad28c0ee4c82e028b0fc5966d", size = 595837, upload-time = "2025-10-14T15:04:25.057Z" },
+    { url = "https://files.pythonhosted.org/packages/57/1e/68c1ed5652b48d89fc24d6af905d88ee4f82fa8bc491e2666004e307ded1/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:620bae625f4cb18427b1bb1a2d9426dc0dd5a5ba74c7c2cdb9de405f7b129863", size = 473456, upload-time = "2025-10-14T15:04:26.497Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/dc/1a680b7458ffa3b14bb64878112aefc8f2e4f73c5af763cbf0bd43100658/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:544364b2b51a9b0c7000a4b4b02f90e9423d97fbbf7e06689236443ebcad81ab", size = 455614, upload-time = "2025-10-14T15:04:27.539Z" },
+    { url = "https://files.pythonhosted.org/packages/61/a5/3d782a666512e01eaa6541a72ebac1d3aae191ff4a31274a66b8dd85760c/watchfiles-1.1.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:bbe1ef33d45bc71cf21364df962af171f96ecaeca06bd9e3d0b583efb12aec82", size = 630690, upload-time = "2025-10-14T15:04:28.495Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/73/bb5f38590e34687b2a9c47a244aa4dd50c56a825969c92c9c5fc7387cea1/watchfiles-1.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:1a0bb430adb19ef49389e1ad368450193a90038b5b752f4ac089ec6942c4dff4", size = 622459, upload-time = "2025-10-14T15:04:29.491Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ac/c9bb0ec696e07a20bd58af5399aeadaef195fb2c73d26baf55180fe4a942/watchfiles-1.1.1-cp310-cp310-win32.whl", hash = "sha256:3f6d37644155fb5beca5378feb8c1708d5783145f2a0f1c4d5a061a210254844", size = 272663, upload-time = "2025-10-14T15:04:30.435Z" },
+    { url = "https://files.pythonhosted.org/packages/11/a0/a60c5a7c2ec59fa062d9a9c61d02e3b6abd94d32aac2d8344c4bdd033326/watchfiles-1.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:a36d8efe0f290835fd0f33da35042a1bb5dc0e83cbc092dcf69bce442579e88e", size = 287453, upload-time = "2025-10-14T15:04:31.53Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f8/2c5f479fb531ce2f0564eda479faecf253d886b1ab3630a39b7bf7362d46/watchfiles-1.1.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:f57b396167a2565a4e8b5e56a5a1c537571733992b226f4f1197d79e94cf0ae5", size = 406529, upload-time = "2025-10-14T15:04:32.899Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/cd/f515660b1f32f65df671ddf6f85bfaca621aee177712874dc30a97397977/watchfiles-1.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:421e29339983e1bebc281fab40d812742268ad057db4aee8c4d2bce0af43b741", size = 394384, upload-time = "2025-10-14T15:04:33.761Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/c3/28b7dc99733eab43fca2d10f55c86e03bd6ab11ca31b802abac26b23d161/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e43d39a741e972bab5d8100b5cdacf69db64e34eb19b6e9af162bccf63c5cc6", size = 448789, upload-time = "2025-10-14T15:04:34.679Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/24/33e71113b320030011c8e4316ccca04194bf0cbbaeee207f00cbc7d6b9f5/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f537afb3276d12814082a2e9b242bdcf416c2e8fd9f799a737990a1dbe906e5b", size = 460521, upload-time = "2025-10-14T15:04:35.963Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/c3/3c9a55f255aa57b91579ae9e98c88704955fa9dac3e5614fb378291155df/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b2cd9e04277e756a2e2d2543d65d1e2166d6fd4c9b183f8808634fda23f17b14", size = 488722, upload-time = "2025-10-14T15:04:37.091Z" },
+    { url = "https://files.pythonhosted.org/packages/49/36/506447b73eb46c120169dc1717fe2eff07c234bb3232a7200b5f5bd816e9/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f3f58818dc0b07f7d9aa7fe9eb1037aecb9700e63e1f6acfed13e9fef648f5d", size = 596088, upload-time = "2025-10-14T15:04:38.39Z" },
+    { url = "https://files.pythonhosted.org/packages/82/ab/5f39e752a9838ec4d52e9b87c1e80f1ee3ccdbe92e183c15b6577ab9de16/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9bb9f66367023ae783551042d31b1d7fd422e8289eedd91f26754a66f44d5cff", size = 472923, upload-time = "2025-10-14T15:04:39.666Z" },
+    { url = "https://files.pythonhosted.org/packages/af/b9/a419292f05e302dea372fa7e6fda5178a92998411f8581b9830d28fb9edb/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aebfd0861a83e6c3d1110b78ad54704486555246e542be3e2bb94195eabb2606", size = 456080, upload-time = "2025-10-14T15:04:40.643Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/c3/d5932fd62bde1a30c36e10c409dc5d54506726f08cb3e1d8d0ba5e2bc8db/watchfiles-1.1.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5fac835b4ab3c6487b5dbad78c4b3724e26bcc468e886f8ba8cc4306f68f6701", size = 629432, upload-time = "2025-10-14T15:04:41.789Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/77/16bddd9779fafb795f1a94319dc965209c5641db5bf1edbbccace6d1b3c0/watchfiles-1.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:399600947b170270e80134ac854e21b3ccdefa11a9529a3decc1327088180f10", size = 623046, upload-time = "2025-10-14T15:04:42.718Z" },
+    { url = "https://files.pythonhosted.org/packages/46/ef/f2ecb9a0f342b4bfad13a2787155c6ee7ce792140eac63a34676a2feeef2/watchfiles-1.1.1-cp311-cp311-win32.whl", hash = "sha256:de6da501c883f58ad50db3a32ad397b09ad29865b5f26f64c24d3e3281685849", size = 271473, upload-time = "2025-10-14T15:04:43.624Z" },
+    { url = "https://files.pythonhosted.org/packages/94/bc/f42d71125f19731ea435c3948cad148d31a64fccde3867e5ba4edee901f9/watchfiles-1.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:35c53bd62a0b885bf653ebf6b700d1bf05debb78ad9292cf2a942b23513dc4c4", size = 287598, upload-time = "2025-10-14T15:04:44.516Z" },
+    { url = "https://files.pythonhosted.org/packages/57/c9/a30f897351f95bbbfb6abcadafbaca711ce1162f4db95fc908c98a9165f3/watchfiles-1.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:57ca5281a8b5e27593cb7d82c2ac927ad88a96ed406aa446f6344e4328208e9e", size = 277210, upload-time = "2025-10-14T15:04:45.883Z" },
+    { url = "https://files.pythonhosted.org/packages/74/d5/f039e7e3c639d9b1d09b07ea412a6806d38123f0508e5f9b48a87b0a76cc/watchfiles-1.1.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:8c89f9f2f740a6b7dcc753140dd5e1ab9215966f7a3530d0c0705c83b401bd7d", size = 404745, upload-time = "2025-10-14T15:04:46.731Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/96/a881a13aa1349827490dab2d363c8039527060cfcc2c92cc6d13d1b1049e/watchfiles-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bd404be08018c37350f0d6e34676bd1e2889990117a2b90070b3007f172d0610", size = 391769, upload-time = "2025-10-14T15:04:48.003Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/5b/d3b460364aeb8da471c1989238ea0e56bec24b6042a68046adf3d9ddb01c/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8526e8f916bb5b9a0a777c8317c23ce65de259422bba5b31325a6fa6029d33af", size = 449374, upload-time = "2025-10-14T15:04:49.179Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/44/5769cb62d4ed055cb17417c0a109a92f007114a4e07f30812a73a4efdb11/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2edc3553362b1c38d9f06242416a5d8e9fe235c204a4072e988ce2e5bb1f69f6", size = 459485, upload-time = "2025-10-14T15:04:50.155Z" },
+    { url = "https://files.pythonhosted.org/packages/19/0c/286b6301ded2eccd4ffd0041a1b726afda999926cf720aab63adb68a1e36/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30f7da3fb3f2844259cba4720c3fc7138eb0f7b659c38f3bfa65084c7fc7abce", size = 488813, upload-time = "2025-10-14T15:04:51.059Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/2b/8530ed41112dd4a22f4dcfdb5ccf6a1baad1ff6eed8dc5a5f09e7e8c41c7/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8979280bdafff686ba5e4d8f97840f929a87ed9cdf133cbbd42f7766774d2aa", size = 594816, upload-time = "2025-10-14T15:04:52.031Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/d2/f5f9fb49489f184f18470d4f99f4e862a4b3e9ac2865688eb2099e3d837a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dcc5c24523771db3a294c77d94771abcfcb82a0e0ee8efd910c37c59ec1b31bb", size = 475186, upload-time = "2025-10-14T15:04:53.064Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803", size = 456812, upload-time = "2025-10-14T15:04:55.174Z" },
+    { url = "https://files.pythonhosted.org/packages/66/ab/3cbb8756323e8f9b6f9acb9ef4ec26d42b2109bce830cc1f3468df20511d/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:28475ddbde92df1874b6c5c8aaeb24ad5be47a11f87cde5a28ef3835932e3e94", size = 630196, upload-time = "2025-10-14T15:04:56.22Z" },
+    { url = "https://files.pythonhosted.org/packages/78/46/7152ec29b8335f80167928944a94955015a345440f524d2dfe63fc2f437b/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:36193ed342f5b9842edd3532729a2ad55c4160ffcfa3700e0d54be496b70dd43", size = 622657, upload-time = "2025-10-14T15:04:57.521Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/bf/95895e78dd75efe9a7f31733607f384b42eb5feb54bd2eb6ed57cc2e94f4/watchfiles-1.1.1-cp312-cp312-win32.whl", hash = "sha256:859e43a1951717cc8de7f4c77674a6d389b106361585951d9e69572823f311d9", size = 272042, upload-time = "2025-10-14T15:04:59.046Z" },
+    { url = "https://files.pythonhosted.org/packages/87/0a/90eb755f568de2688cb220171c4191df932232c20946966c27a59c400850/watchfiles-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:91d4c9a823a8c987cce8fa2690923b069966dabb196dd8d137ea2cede885fde9", size = 288410, upload-time = "2025-10-14T15:05:00.081Z" },
+    { url = "https://files.pythonhosted.org/packages/36/76/f322701530586922fbd6723c4f91ace21364924822a8772c549483abed13/watchfiles-1.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:a625815d4a2bdca61953dbba5a39d60164451ef34c88d751f6c368c3ea73d404", size = 278209, upload-time = "2025-10-14T15:05:01.168Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/f4/f750b29225fe77139f7ae5de89d4949f5a99f934c65a1f1c0b248f26f747/watchfiles-1.1.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:130e4876309e8686a5e37dba7d5e9bc77e6ed908266996ca26572437a5271e18", size = 404321, upload-time = "2025-10-14T15:05:02.063Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/f9/f07a295cde762644aa4c4bb0f88921d2d141af45e735b965fb2e87858328/watchfiles-1.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5f3bde70f157f84ece3765b42b4a52c6ac1a50334903c6eaf765362f6ccca88a", size = 391783, upload-time = "2025-10-14T15:05:03.052Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/11/fc2502457e0bea39a5c958d86d2cb69e407a4d00b85735ca724bfa6e0d1a/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:14e0b1fe858430fc0251737ef3824c54027bedb8c37c38114488b8e131cf8219", size = 449279, upload-time = "2025-10-14T15:05:04.004Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/1f/d66bc15ea0b728df3ed96a539c777acfcad0eb78555ad9efcaa1274688f0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f27db948078f3823a6bb3b465180db8ebecf26dd5dae6f6180bd87383b6b4428", size = 459405, upload-time = "2025-10-14T15:05:04.942Z" },
+    { url = "https://files.pythonhosted.org/packages/be/90/9f4a65c0aec3ccf032703e6db02d89a157462fbb2cf20dd415128251cac0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:059098c3a429f62fc98e8ec62b982230ef2c8df68c79e826e37b895bc359a9c0", size = 488976, upload-time = "2025-10-14T15:05:05.905Z" },
+    { url = "https://files.pythonhosted.org/packages/37/57/ee347af605d867f712be7029bb94c8c071732a4b44792e3176fa3c612d39/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfb5862016acc9b869bb57284e6cb35fdf8e22fe59f7548858e2f971d045f150", size = 595506, upload-time = "2025-10-14T15:05:06.906Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/78/cc5ab0b86c122047f75e8fc471c67a04dee395daf847d3e59381996c8707/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:319b27255aacd9923b8a276bb14d21a5f7ff82564c744235fc5eae58d95422ae", size = 474936, upload-time = "2025-10-14T15:05:07.906Z" },
+    { url = "https://files.pythonhosted.org/packages/62/da/def65b170a3815af7bd40a3e7010bf6ab53089ef1b75d05dd5385b87cf08/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c755367e51db90e75b19454b680903631d41f9e3607fbd941d296a020c2d752d", size = 456147, upload-time = "2025-10-14T15:05:09.138Z" },
+    { url = "https://files.pythonhosted.org/packages/57/99/da6573ba71166e82d288d4df0839128004c67d2778d3b566c138695f5c0b/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c22c776292a23bfc7237a98f791b9ad3144b02116ff10d820829ce62dff46d0b", size = 630007, upload-time = "2025-10-14T15:05:10.117Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/51/7439c4dd39511368849eb1e53279cd3454b4a4dbace80bab88feeb83c6b5/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:3a476189be23c3686bc2f4321dd501cb329c0a0469e77b7b534ee10129ae6374", size = 622280, upload-time = "2025-10-14T15:05:11.146Z" },
+    { url = "https://files.pythonhosted.org/packages/95/9c/8ed97d4bba5db6fdcdb2b298d3898f2dd5c20f6b73aee04eabe56c59677e/watchfiles-1.1.1-cp313-cp313-win32.whl", hash = "sha256:bf0a91bfb5574a2f7fc223cf95eeea79abfefa404bf1ea5e339c0c1560ae99a0", size = 272056, upload-time = "2025-10-14T15:05:12.156Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f3/c14e28429f744a260d8ceae18bf58c1d5fa56b50d006a7a9f80e1882cb0d/watchfiles-1.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:52e06553899e11e8074503c8e716d574adeeb7e68913115c4b3653c53f9bae42", size = 288162, upload-time = "2025-10-14T15:05:13.208Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/61/fe0e56c40d5cd29523e398d31153218718c5786b5e636d9ae8ae79453d27/watchfiles-1.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:ac3cc5759570cd02662b15fbcd9d917f7ecd47efe0d6b40474eafd246f91ea18", size = 277909, upload-time = "2025-10-14T15:05:14.49Z" },
+    { url = "https://files.pythonhosted.org/packages/79/42/e0a7d749626f1e28c7108a99fb9bf524b501bbbeb9b261ceecde644d5a07/watchfiles-1.1.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:563b116874a9a7ce6f96f87cd0b94f7faf92d08d0021e837796f0a14318ef8da", size = 403389, upload-time = "2025-10-14T15:05:15.777Z" },
+    { url = "https://files.pythonhosted.org/packages/15/49/08732f90ce0fbbc13913f9f215c689cfc9ced345fb1bcd8829a50007cc8d/watchfiles-1.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3ad9fe1dae4ab4212d8c91e80b832425e24f421703b5a42ef2e4a1e215aff051", size = 389964, upload-time = "2025-10-14T15:05:16.85Z" },
+    { url = "https://files.pythonhosted.org/packages/27/0d/7c315d4bd5f2538910491a0393c56bf70d333d51bc5b34bee8e68e8cea19/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce70f96a46b894b36eba678f153f052967a0d06d5b5a19b336ab0dbbd029f73e", size = 448114, upload-time = "2025-10-14T15:05:17.876Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/24/9e096de47a4d11bc4df41e9d1e61776393eac4cb6eb11b3e23315b78b2cc/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cb467c999c2eff23a6417e58d75e5828716f42ed8289fe6b77a7e5a91036ca70", size = 460264, upload-time = "2025-10-14T15:05:18.962Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/0f/e8dea6375f1d3ba5fcb0b3583e2b493e77379834c74fd5a22d66d85d6540/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:836398932192dae4146c8f6f737d74baeac8b70ce14831a239bdb1ca882fc261", size = 487877, upload-time = "2025-10-14T15:05:20.094Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/5b/df24cfc6424a12deb41503b64d42fbea6b8cb357ec62ca84a5a3476f654a/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:743185e7372b7bc7c389e1badcc606931a827112fbbd37f14c537320fca08620", size = 595176, upload-time = "2025-10-14T15:05:21.134Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/b5/853b6757f7347de4e9b37e8cc3289283fb983cba1ab4d2d7144694871d9c/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:afaeff7696e0ad9f02cbb8f56365ff4686ab205fcf9c4c5b6fdfaaa16549dd04", size = 473577, upload-time = "2025-10-14T15:05:22.306Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/f7/0a4467be0a56e80447c8529c9fce5b38eab4f513cb3d9bf82e7392a5696b/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7eb7da0eb23aa2ba036d4f616d46906013a68caf61b7fdbe42fc8b25132e77", size = 455425, upload-time = "2025-10-14T15:05:23.348Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e0/82583485ea00137ddf69bc84a2db88bd92ab4a6e3c405e5fb878ead8d0e7/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:831a62658609f0e5c64178211c942ace999517f5770fe9436be4c2faeba0c0ef", size = 628826, upload-time = "2025-10-14T15:05:24.398Z" },
+    { url = "https://files.pythonhosted.org/packages/28/9a/a785356fccf9fae84c0cc90570f11702ae9571036fb25932f1242c82191c/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f9a2ae5c91cecc9edd47e041a930490c31c3afb1f5e6d71de3dc671bfaca02bf", size = 622208, upload-time = "2025-10-14T15:05:25.45Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/4c/a888c91e2e326872fa4705095d64acd8aa2fb9c1f7b9bd0588f33850516c/watchfiles-1.1.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:17ef139237dfced9da49fb7f2232c86ca9421f666d78c264c7ffca6601d154c3", size = 409611, upload-time = "2025-10-14T15:06:05.809Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/c7/5420d1943c8e3ce1a21c0a9330bcf7edafb6aa65d26b21dbb3267c9e8112/watchfiles-1.1.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:672b8adf25b1a0d35c96b5888b7b18699d27d4194bac8beeae75be4b7a3fc9b2", size = 396889, upload-time = "2025-10-14T15:06:07.035Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/e5/0072cef3804ce8d3aaddbfe7788aadff6b3d3f98a286fdbee9fd74ca59a7/watchfiles-1.1.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77a13aea58bc2b90173bc69f2a90de8e282648939a00a602e1dc4ee23e26b66d", size = 451616, upload-time = "2025-10-14T15:06:08.072Z" },
+    { url = "https://files.pythonhosted.org/packages/83/4e/b87b71cbdfad81ad7e83358b3e447fedd281b880a03d64a760fe0a11fc2e/watchfiles-1.1.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b495de0bb386df6a12b18335a0285dda90260f51bdb505503c02bcd1ce27a8b", size = 458413, upload-time = "2025-10-14T15:06:09.209Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/8e/e500f8b0b77be4ff753ac94dc06b33d8f0d839377fee1b78e8c8d8f031bf/watchfiles-1.1.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:db476ab59b6765134de1d4fe96a1a9c96ddf091683599be0f26147ea1b2e4b88", size = 408250, upload-time = "2025-10-14T15:06:10.264Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/95/615e72cd27b85b61eec764a5ca51bd94d40b5adea5ff47567d9ebc4d275a/watchfiles-1.1.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:89eef07eee5e9d1fda06e38822ad167a044153457e6fd997f8a858ab7564a336", size = 396117, upload-time = "2025-10-14T15:06:11.28Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/81/e7fe958ce8a7fb5c73cc9fb07f5aeaf755e6aa72498c57d760af760c91f8/watchfiles-1.1.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce19e06cbda693e9e7686358af9cd6f5d61312ab8b00488bc36f5aabbaf77e24", size = 450493, upload-time = "2025-10-14T15:06:12.321Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/d4/ed38dd3b1767193de971e694aa544356e63353c33a85d948166b5ff58b9e/watchfiles-1.1.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e6f39af2eab0118338902798b5aa6664f46ff66bc0280de76fca67a7f262a49", size = 457546, upload-time = "2025-10-14T15:06:13.372Z" },
+]
+
+[[package]]
+name = "wcwidth"
+version = "0.2.14"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/30/6b0809f4510673dc723187aeaf24c7f5459922d01e2f794277a3dfb90345/wcwidth-0.2.14.tar.gz", hash = "sha256:4d478375d31bc5395a3c55c40ccdf3354688364cd61c4f6adacaa9215d0b3605", size = 102293, upload-time = "2025-09-22T16:29:53.023Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/af/b5/123f13c975e9f27ab9c0770f514345bd406d0e8d3b7a0723af9d43f710af/wcwidth-0.2.14-py2.py3-none-any.whl", hash = "sha256:a7bb560c8aee30f9957e5f9895805edd20602f2d7f720186dfd906e82b4982e1", size = 37286, upload-time = "2025-09-22T16:29:51.641Z" },
+]
+
+[[package]]
+name = "websockets"
+version = "15.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/da/6462a9f510c0c49837bbc9345aca92d767a56c1fb2939e1579df1e1cdcf7/websockets-15.0.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d63efaa0cd96cf0c5fe4d581521d9fa87744540d4bc999ae6e08595a1014b45b", size = 175423, upload-time = "2025-03-05T20:01:35.363Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/9f/9d11c1a4eb046a9e106483b9ff69bce7ac880443f00e5ce64261b47b07e7/websockets-15.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ac60e3b188ec7574cb761b08d50fcedf9d77f1530352db4eef1707fe9dee7205", size = 173080, upload-time = "2025-03-05T20:01:37.304Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/4f/b462242432d93ea45f297b6179c7333dd0402b855a912a04e7fc61c0d71f/websockets-15.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5756779642579d902eed757b21b0164cd6fe338506a8083eb58af5c372e39d9a", size = 173329, upload-time = "2025-03-05T20:01:39.668Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0c/6afa1f4644d7ed50284ac59cc70ef8abd44ccf7d45850d989ea7310538d0/websockets-15.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fdfe3e2a29e4db3659dbd5bbf04560cea53dd9610273917799f1cde46aa725e", size = 182312, upload-time = "2025-03-05T20:01:41.815Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/d4/ffc8bd1350b229ca7a4db2a3e1c482cf87cea1baccd0ef3e72bc720caeec/websockets-15.0.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c2529b320eb9e35af0fa3016c187dffb84a3ecc572bcee7c3ce302bfeba52bf", size = 181319, upload-time = "2025-03-05T20:01:43.967Z" },
+    { url = "https://files.pythonhosted.org/packages/97/3a/5323a6bb94917af13bbb34009fac01e55c51dfde354f63692bf2533ffbc2/websockets-15.0.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac1e5c9054fe23226fb11e05a6e630837f074174c4c2f0fe442996112a6de4fb", size = 181631, upload-time = "2025-03-05T20:01:46.104Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/cc/1aeb0f7cee59ef065724041bb7ed667b6ab1eeffe5141696cccec2687b66/websockets-15.0.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5df592cd503496351d6dc14f7cdad49f268d8e618f80dce0cd5a36b93c3fc08d", size = 182016, upload-time = "2025-03-05T20:01:47.603Z" },
+    { url = "https://files.pythonhosted.org/packages/79/f9/c86f8f7af208e4161a7f7e02774e9d0a81c632ae76db2ff22549e1718a51/websockets-15.0.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0a34631031a8f05657e8e90903e656959234f3a04552259458aac0b0f9ae6fd9", size = 181426, upload-time = "2025-03-05T20:01:48.949Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/b9/828b0bc6753db905b91df6ae477c0b14a141090df64fb17f8a9d7e3516cf/websockets-15.0.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3d00075aa65772e7ce9e990cab3ff1de702aa09be3940d1dc88d5abf1ab8a09c", size = 181360, upload-time = "2025-03-05T20:01:50.938Z" },
+    { url = "https://files.pythonhosted.org/packages/89/fb/250f5533ec468ba6327055b7d98b9df056fb1ce623b8b6aaafb30b55d02e/websockets-15.0.1-cp310-cp310-win32.whl", hash = "sha256:1234d4ef35db82f5446dca8e35a7da7964d02c127b095e172e54397fb6a6c256", size = 176388, upload-time = "2025-03-05T20:01:52.213Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/46/aca7082012768bb98e5608f01658ff3ac8437e563eca41cf068bd5849a5e/websockets-15.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:39c1fec2c11dc8d89bba6b2bf1556af381611a173ac2b511cf7231622058af41", size = 176830, upload-time = "2025-03-05T20:01:53.922Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423, upload-time = "2025-03-05T20:01:56.276Z" },
+    { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082, upload-time = "2025-03-05T20:01:57.563Z" },
+    { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330, upload-time = "2025-03-05T20:01:59.063Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878, upload-time = "2025-03-05T20:02:00.305Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883, upload-time = "2025-03-05T20:02:03.148Z" },
+    { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252, upload-time = "2025-03-05T20:02:05.29Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521, upload-time = "2025-03-05T20:02:07.458Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958, upload-time = "2025-03-05T20:02:09.842Z" },
+    { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918, upload-time = "2025-03-05T20:02:11.968Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388, upload-time = "2025-03-05T20:02:13.32Z" },
+    { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828, upload-time = "2025-03-05T20:02:14.585Z" },
+    { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" },
+    { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" },
+    { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" },
+    { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload-time = "2025-03-05T20:02:36.695Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload-time = "2025-03-05T20:02:37.985Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload-time = "2025-03-05T20:02:39.298Z" },
+    { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111, upload-time = "2025-03-05T20:02:40.595Z" },
+    { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054, upload-time = "2025-03-05T20:02:41.926Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496, upload-time = "2025-03-05T20:02:43.304Z" },
+    { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829, upload-time = "2025-03-05T20:02:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217, upload-time = "2025-03-05T20:02:50.14Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195, upload-time = "2025-03-05T20:02:51.561Z" },
+    { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393, upload-time = "2025-03-05T20:02:53.814Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837, upload-time = "2025-03-05T20:02:55.237Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/d40f779fa16f74d3468357197af8d6ad07e7c5a27ea1ca74ceb38986f77a/websockets-15.0.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0c9e74d766f2818bb95f84c25be4dea09841ac0f734d1966f415e4edfc4ef1c3", size = 173109, upload-time = "2025-03-05T20:03:17.769Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/cd/5b887b8585a593073fd92f7c23ecd3985cd2c3175025a91b0d69b0551372/websockets-15.0.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:1009ee0c7739c08a0cd59de430d6de452a55e42d6b522de7aa15e6f67db0b8e1", size = 173343, upload-time = "2025-03-05T20:03:19.094Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/ae/d34f7556890341e900a95acf4886833646306269f899d58ad62f588bf410/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76d1f20b1c7a2fa82367e04982e708723ba0e7b8d43aa643d3dcd404d74f1475", size = 174599, upload-time = "2025-03-05T20:03:21.1Z" },
+    { url = "https://files.pythonhosted.org/packages/71/e6/5fd43993a87db364ec60fc1d608273a1a465c0caba69176dd160e197ce42/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f29d80eb9a9263b8d109135351caf568cc3f80b9928bccde535c235de55c22d9", size = 174207, upload-time = "2025-03-05T20:03:23.221Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/fb/c492d6daa5ec067c2988ac80c61359ace5c4c674c532985ac5a123436cec/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b359ed09954d7c18bbc1680f380c7301f92c60bf924171629c5db97febb12f04", size = 174155, upload-time = "2025-03-05T20:03:25.321Z" },
+    { url = "https://files.pythonhosted.org/packages/68/a1/dcb68430b1d00b698ae7a7e0194433bce4f07ded185f0ee5fb21e2a2e91e/websockets-15.0.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:cad21560da69f4ce7658ca2cb83138fb4cf695a2ba3e475e0559e05991aa8122", size = 176884, upload-time = "2025-03-05T20:03:27.934Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" },
+]
+
+[[package]]
+name = "werkzeug"
+version = "3.1.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b5/43/76ded108b296a49f52de6bac5192ca1c4be84e886f9b5c9ba8427d9694fd/werkzeug-3.1.7.tar.gz", hash = "sha256:fb8c01fe6ab13b9b7cdb46892b99b1d66754e1d7ab8e542e865ec13f526b5351", size = 875700, upload-time = "2026-03-24T01:08:07.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7f/b2/0bba9bbb4596d2d2f285a16c2ab04118f6b957d8441566e1abb892e6a6b2/werkzeug-3.1.7-py3-none-any.whl", hash = "sha256:4b314d81163a3e1a169b6a0be2a000a0e204e8873c5de6586f453c55688d422f", size = 226295, upload-time = "2026-03-24T01:08:06.133Z" },
+]
+
+[[package]]
+name = "wrapt"
+version = "2.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/49/2a/6de8a50cb435b7f42c46126cf1a54b2aab81784e74c8595c8e025e8f36d3/wrapt-2.0.1.tar.gz", hash = "sha256:9c9c635e78497cacb81e84f8b11b23e0aacac7a136e73b8e5b2109a1d9fc468f", size = 82040, upload-time = "2025-11-07T00:45:33.312Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/61/0d/12d8c803ed2ce4e5e7d5b9f5f602721f9dfef82c95959f3ce97fa584bb5c/wrapt-2.0.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:64b103acdaa53b7caf409e8d45d39a8442fe6dcfec6ba3f3d141e0cc2b5b4dbd", size = 77481, upload-time = "2025-11-07T00:43:11.103Z" },
+    { url = "https://files.pythonhosted.org/packages/05/3e/4364ebe221ebf2a44d9fc8695a19324692f7dd2795e64bd59090856ebf12/wrapt-2.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:91bcc576260a274b169c3098e9a3519fb01f2989f6d3d386ef9cbf8653de1374", size = 60692, upload-time = "2025-11-07T00:43:13.697Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/ff/ae2a210022b521f86a8ddcdd6058d137c051003812b0388a5e9a03d3fe10/wrapt-2.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ab594f346517010050126fcd822697b25a7031d815bb4fbc238ccbe568216489", size = 61574, upload-time = "2025-11-07T00:43:14.967Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/93/5cf92edd99617095592af919cb81d4bff61c5dbbb70d3c92099425a8ec34/wrapt-2.0.1-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:36982b26f190f4d737f04a492a68accbfc6fa042c3f42326fdfbb6c5b7a20a31", size = 113688, upload-time = "2025-11-07T00:43:18.275Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/0a/e38fc0cee1f146c9fb266d8ef96ca39fb14a9eef165383004019aa53f88a/wrapt-2.0.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:23097ed8bc4c93b7bf36fa2113c6c733c976316ce0ee2c816f64ca06102034ef", size = 115698, upload-time = "2025-11-07T00:43:19.407Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/85/bef44ea018b3925fb0bcbe9112715f665e4d5309bd945191da814c314fd1/wrapt-2.0.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8bacfe6e001749a3b64db47bcf0341da757c95959f592823a93931a422395013", size = 112096, upload-time = "2025-11-07T00:43:16.5Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/0b/733a2376e413117e497aa1a5b1b78e8f3a28c0e9537d26569f67d724c7c5/wrapt-2.0.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:8ec3303e8a81932171f455f792f8df500fc1a09f20069e5c16bd7049ab4e8e38", size = 114878, upload-time = "2025-11-07T00:43:20.81Z" },
+    { url = "https://files.pythonhosted.org/packages/da/03/d81dcb21bbf678fcda656495792b059f9d56677d119ca022169a12542bd0/wrapt-2.0.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:3f373a4ab5dbc528a94334f9fe444395b23c2f5332adab9ff4ea82f5a9e33bc1", size = 111298, upload-time = "2025-11-07T00:43:22.229Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d5/5e623040e8056e1108b787020d56b9be93dbbf083bf2324d42cde80f3a19/wrapt-2.0.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f49027b0b9503bf6c8cdc297ca55006b80c2f5dd36cecc72c6835ab6e10e8a25", size = 113361, upload-time = "2025-11-07T00:43:24.301Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/f3/de535ccecede6960e28c7b722e5744846258111d6c9f071aa7578ea37ad3/wrapt-2.0.1-cp310-cp310-win32.whl", hash = "sha256:8330b42d769965e96e01fa14034b28a2a7600fbf7e8f0cc90ebb36d492c993e4", size = 58035, upload-time = "2025-11-07T00:43:28.96Z" },
+    { url = "https://files.pythonhosted.org/packages/21/15/39d3ca5428a70032c2ec8b1f1c9d24c32e497e7ed81aed887a4998905fcc/wrapt-2.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:1218573502a8235bb8a7ecaed12736213b22dcde9feab115fa2989d42b5ded45", size = 60383, upload-time = "2025-11-07T00:43:25.804Z" },
+    { url = "https://files.pythonhosted.org/packages/43/c2/dfd23754b7f7a4dce07e08f4309c4e10a40046a83e9ae1800f2e6b18d7c1/wrapt-2.0.1-cp310-cp310-win_arm64.whl", hash = "sha256:eda8e4ecd662d48c28bb86be9e837c13e45c58b8300e43ba3c9b4fa9900302f7", size = 58894, upload-time = "2025-11-07T00:43:27.074Z" },
+    { url = "https://files.pythonhosted.org/packages/98/60/553997acf3939079dab022e37b67b1904b5b0cc235503226898ba573b10c/wrapt-2.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0e17283f533a0d24d6e5429a7d11f250a58d28b4ae5186f8f47853e3e70d2590", size = 77480, upload-time = "2025-11-07T00:43:30.573Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/50/e5b3d30895d77c52105c6d5cbf94d5b38e2a3dd4a53d22d246670da98f7c/wrapt-2.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:85df8d92158cb8f3965aecc27cf821461bb5f40b450b03facc5d9f0d4d6ddec6", size = 60690, upload-time = "2025-11-07T00:43:31.594Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/40/660b2898703e5cbbb43db10cdefcc294274458c3ca4c68637c2b99371507/wrapt-2.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c1be685ac7700c966b8610ccc63c3187a72e33cab53526a27b2a285a662cd4f7", size = 61578, upload-time = "2025-11-07T00:43:32.918Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/36/825b44c8a10556957bc0c1d84c7b29a40e05fcf1873b6c40aa9dbe0bd972/wrapt-2.0.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:df0b6d3b95932809c5b3fecc18fda0f1e07452d05e2662a0b35548985f256e28", size = 114115, upload-time = "2025-11-07T00:43:35.605Z" },
+    { url = "https://files.pythonhosted.org/packages/83/73/0a5d14bb1599677304d3c613a55457d34c344e9b60eda8a737c2ead7619e/wrapt-2.0.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4da7384b0e5d4cae05c97cd6f94faaf78cc8b0f791fc63af43436d98c4ab37bb", size = 116157, upload-time = "2025-11-07T00:43:37.058Z" },
+    { url = "https://files.pythonhosted.org/packages/01/22/1c158fe763dbf0a119f985d945711d288994fe5514c0646ebe0eb18b016d/wrapt-2.0.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ec65a78fbd9d6f083a15d7613b2800d5663dbb6bb96003899c834beaa68b242c", size = 112535, upload-time = "2025-11-07T00:43:34.138Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/28/4f16861af67d6de4eae9927799b559c20ebdd4fe432e89ea7fe6fcd9d709/wrapt-2.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7de3cc939be0e1174969f943f3b44e0d79b6f9a82198133a5b7fc6cc92882f16", size = 115404, upload-time = "2025-11-07T00:43:39.214Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/8b/7960122e625fad908f189b59c4aae2d50916eb4098b0fb2819c5a177414f/wrapt-2.0.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:fb1a5b72cbd751813adc02ef01ada0b0d05d3dcbc32976ce189a1279d80ad4a2", size = 111802, upload-time = "2025-11-07T00:43:40.476Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/73/7881eee5ac31132a713ab19a22c9e5f1f7365c8b1df50abba5d45b781312/wrapt-2.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3fa272ca34332581e00bf7773e993d4f632594eb2d1b0b162a9038df0fd971dd", size = 113837, upload-time = "2025-11-07T00:43:42.921Z" },
+    { url = "https://files.pythonhosted.org/packages/45/00/9499a3d14e636d1f7089339f96c4409bbc7544d0889f12264efa25502ae8/wrapt-2.0.1-cp311-cp311-win32.whl", hash = "sha256:fc007fdf480c77301ab1afdbb6ab22a5deee8885f3b1ed7afcb7e5e84a0e27be", size = 58028, upload-time = "2025-11-07T00:43:47.369Z" },
+    { url = "https://files.pythonhosted.org/packages/70/5d/8f3d7eea52f22638748f74b102e38fdf88cb57d08ddeb7827c476a20b01b/wrapt-2.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:47434236c396d04875180171ee1f3815ca1eada05e24a1ee99546320d54d1d1b", size = 60385, upload-time = "2025-11-07T00:43:44.34Z" },
+    { url = "https://files.pythonhosted.org/packages/14/e2/32195e57a8209003587bbbad44d5922f13e0ced2a493bb46ca882c5b123d/wrapt-2.0.1-cp311-cp311-win_arm64.whl", hash = "sha256:837e31620e06b16030b1d126ed78e9383815cbac914693f54926d816d35d8edf", size = 58893, upload-time = "2025-11-07T00:43:46.161Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/73/8cb252858dc8254baa0ce58ce382858e3a1cf616acebc497cb13374c95c6/wrapt-2.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1fdbb34da15450f2b1d735a0e969c24bdb8d8924892380126e2a293d9902078c", size = 78129, upload-time = "2025-11-07T00:43:48.852Z" },
+    { url = "https://files.pythonhosted.org/packages/19/42/44a0db2108526ee6e17a5ab72478061158f34b08b793df251d9fbb9a7eb4/wrapt-2.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3d32794fe940b7000f0519904e247f902f0149edbe6316c710a8562fb6738841", size = 61205, upload-time = "2025-11-07T00:43:50.402Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/8a/5b4b1e44b791c22046e90d9b175f9a7581a8cc7a0debbb930f81e6ae8e25/wrapt-2.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:386fb54d9cd903ee0012c09291336469eb7b244f7183d40dc3e86a16a4bace62", size = 61692, upload-time = "2025-11-07T00:43:51.678Z" },
+    { url = "https://files.pythonhosted.org/packages/11/53/3e794346c39f462bcf1f58ac0487ff9bdad02f9b6d5ee2dc84c72e0243b2/wrapt-2.0.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7b219cb2182f230676308cdcacd428fa837987b89e4b7c5c9025088b8a6c9faf", size = 121492, upload-time = "2025-11-07T00:43:55.017Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/7e/10b7b0e8841e684c8ca76b462a9091c45d62e8f2de9c4b1390b690eadf16/wrapt-2.0.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:641e94e789b5f6b4822bb8d8ebbdfc10f4e4eae7756d648b717d980f657a9eb9", size = 123064, upload-time = "2025-11-07T00:43:56.323Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/d1/3c1e4321fc2f5ee7fd866b2d822aa89b84495f28676fd976c47327c5b6aa/wrapt-2.0.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fe21b118b9f58859b5ebaa4b130dee18669df4bd111daad082b7beb8799ad16b", size = 117403, upload-time = "2025-11-07T00:43:53.258Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/b0/d2f0a413cf201c8c2466de08414a15420a25aa83f53e647b7255cc2fab5d/wrapt-2.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:17fb85fa4abc26a5184d93b3efd2dcc14deb4b09edcdb3535a536ad34f0b4dba", size = 121500, upload-time = "2025-11-07T00:43:57.468Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/45/bddb11d28ca39970a41ed48a26d210505120f925918592283369219f83cc/wrapt-2.0.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:b89ef9223d665ab255ae42cc282d27d69704d94be0deffc8b9d919179a609684", size = 116299, upload-time = "2025-11-07T00:43:58.877Z" },
+    { url = "https://files.pythonhosted.org/packages/81/af/34ba6dd570ef7a534e7eec0c25e2615c355602c52aba59413411c025a0cb/wrapt-2.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a453257f19c31b31ba593c30d997d6e5be39e3b5ad9148c2af5a7314061c63eb", size = 120622, upload-time = "2025-11-07T00:43:59.962Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/3e/693a13b4146646fb03254636f8bafd20c621955d27d65b15de07ab886187/wrapt-2.0.1-cp312-cp312-win32.whl", hash = "sha256:3e271346f01e9c8b1130a6a3b0e11908049fe5be2d365a5f402778049147e7e9", size = 58246, upload-time = "2025-11-07T00:44:03.169Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/36/715ec5076f925a6be95f37917b66ebbeaa1372d1862c2ccd7a751574b068/wrapt-2.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:2da620b31a90cdefa9cd0c2b661882329e2e19d1d7b9b920189956b76c564d75", size = 60492, upload-time = "2025-11-07T00:44:01.027Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/3e/62451cd7d80f65cc125f2b426b25fbb6c514bf6f7011a0c3904fc8c8df90/wrapt-2.0.1-cp312-cp312-win_arm64.whl", hash = "sha256:aea9c7224c302bc8bfc892b908537f56c430802560e827b75ecbde81b604598b", size = 58987, upload-time = "2025-11-07T00:44:02.095Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/fe/41af4c46b5e498c90fc87981ab2972fbd9f0bccda597adb99d3d3441b94b/wrapt-2.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:47b0f8bafe90f7736151f61482c583c86b0693d80f075a58701dd1549b0010a9", size = 78132, upload-time = "2025-11-07T00:44:04.628Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/92/d68895a984a5ebbbfb175512b0c0aad872354a4a2484fbd5552e9f275316/wrapt-2.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:cbeb0971e13b4bd81d34169ed57a6dda017328d1a22b62fda45e1d21dd06148f", size = 61211, upload-time = "2025-11-07T00:44:05.626Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/26/ba83dc5ae7cf5aa2b02364a3d9cf74374b86169906a1f3ade9a2d03cf21c/wrapt-2.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb7cffe572ad0a141a7886a1d2efa5bef0bf7fe021deeea76b3ab334d2c38218", size = 61689, upload-time = "2025-11-07T00:44:06.719Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/67/d7a7c276d874e5d26738c22444d466a3a64ed541f6ef35f740dbd865bab4/wrapt-2.0.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c8d60527d1ecfc131426b10d93ab5d53e08a09c5fa0175f6b21b3252080c70a9", size = 121502, upload-time = "2025-11-07T00:44:09.557Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/6b/806dbf6dd9579556aab22fc92908a876636e250f063f71548a8660382184/wrapt-2.0.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c654eafb01afac55246053d67a4b9a984a3567c3808bb7df2f8de1c1caba2e1c", size = 123110, upload-time = "2025-11-07T00:44:10.64Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/08/cdbb965fbe4c02c5233d185d070cabed2ecc1f1e47662854f95d77613f57/wrapt-2.0.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:98d873ed6c8b4ee2418f7afce666751854d6d03e3c0ec2a399bb039cd2ae89db", size = 117434, upload-time = "2025-11-07T00:44:08.138Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/d1/6aae2ce39db4cb5216302fa2e9577ad74424dfbe315bd6669725569e048c/wrapt-2.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c9e850f5b7fc67af856ff054c71690d54fa940c3ef74209ad9f935b4f66a0233", size = 121533, upload-time = "2025-11-07T00:44:12.142Z" },
+    { url = "https://files.pythonhosted.org/packages/79/35/565abf57559fbe0a9155c29879ff43ce8bd28d2ca61033a3a3dd67b70794/wrapt-2.0.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e505629359cb5f751e16e30cf3f91a1d3ddb4552480c205947da415d597f7ac2", size = 116324, upload-time = "2025-11-07T00:44:13.28Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/e0/53ff5e76587822ee33e560ad55876d858e384158272cd9947abdd4ad42ca/wrapt-2.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2879af909312d0baf35f08edeea918ee3af7ab57c37fe47cb6a373c9f2749c7b", size = 120627, upload-time = "2025-11-07T00:44:14.431Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/7b/38df30fd629fbd7612c407643c63e80e1c60bcc982e30ceeae163a9800e7/wrapt-2.0.1-cp313-cp313-win32.whl", hash = "sha256:d67956c676be5a24102c7407a71f4126d30de2a569a1c7871c9f3cabc94225d7", size = 58252, upload-time = "2025-11-07T00:44:17.814Z" },
+    { url = "https://files.pythonhosted.org/packages/85/64/d3954e836ea67c4d3ad5285e5c8fd9d362fd0a189a2db622df457b0f4f6a/wrapt-2.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:9ca66b38dd642bf90c59b6738af8070747b610115a39af2498535f62b5cdc1c3", size = 60500, upload-time = "2025-11-07T00:44:15.561Z" },
+    { url = "https://files.pythonhosted.org/packages/89/4e/3c8b99ac93527cfab7f116089db120fef16aac96e5f6cdb724ddf286086d/wrapt-2.0.1-cp313-cp313-win_arm64.whl", hash = "sha256:5a4939eae35db6b6cec8e7aa0e833dcca0acad8231672c26c2a9ab7a0f8ac9c8", size = 58993, upload-time = "2025-11-07T00:44:16.65Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/f4/eff2b7d711cae20d220780b9300faa05558660afb93f2ff5db61fe725b9a/wrapt-2.0.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a52f93d95c8d38fed0669da2ebdb0b0376e895d84596a976c15a9eb45e3eccb3", size = 82028, upload-time = "2025-11-07T00:44:18.944Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/67/cb945563f66fd0f61a999339460d950f4735c69f18f0a87ca586319b1778/wrapt-2.0.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4e54bbf554ee29fcceee24fa41c4d091398b911da6e7f5d7bffda963c9aed2e1", size = 62949, upload-time = "2025-11-07T00:44:20.074Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/ca/f63e177f0bbe1e5cf5e8d9b74a286537cd709724384ff20860f8f6065904/wrapt-2.0.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:908f8c6c71557f4deaa280f55d0728c3bca0960e8c3dd5ceeeafb3c19942719d", size = 63681, upload-time = "2025-11-07T00:44:21.345Z" },
+    { url = "https://files.pythonhosted.org/packages/39/a1/1b88fcd21fd835dca48b556daef750952e917a2794fa20c025489e2e1f0f/wrapt-2.0.1-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e2f84e9af2060e3904a32cea9bb6db23ce3f91cfd90c6b426757cf7cc01c45c7", size = 152696, upload-time = "2025-11-07T00:44:24.318Z" },
+    { url = "https://files.pythonhosted.org/packages/62/1c/d9185500c1960d9f5f77b9c0b890b7fc62282b53af7ad1b6bd779157f714/wrapt-2.0.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e3612dc06b436968dfb9142c62e5dfa9eb5924f91120b3c8ff501ad878f90eb3", size = 158859, upload-time = "2025-11-07T00:44:25.494Z" },
+    { url = "https://files.pythonhosted.org/packages/91/60/5d796ed0f481ec003220c7878a1d6894652efe089853a208ea0838c13086/wrapt-2.0.1-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6d2d947d266d99a1477cd005b23cbd09465276e302515e122df56bb9511aca1b", size = 146068, upload-time = "2025-11-07T00:44:22.81Z" },
+    { url = "https://files.pythonhosted.org/packages/04/f8/75282dd72f102ddbfba137e1e15ecba47b40acff32c08ae97edbf53f469e/wrapt-2.0.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:7d539241e87b650cbc4c3ac9f32c8d1ac8a54e510f6dca3f6ab60dcfd48c9b10", size = 155724, upload-time = "2025-11-07T00:44:26.634Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/27/fe39c51d1b344caebb4a6a9372157bdb8d25b194b3561b52c8ffc40ac7d1/wrapt-2.0.1-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:4811e15d88ee62dbf5c77f2c3ff3932b1e3ac92323ba3912f51fc4016ce81ecf", size = 144413, upload-time = "2025-11-07T00:44:27.939Z" },
+    { url = "https://files.pythonhosted.org/packages/83/2b/9f6b643fe39d4505c7bf926d7c2595b7cb4b607c8c6b500e56c6b36ac238/wrapt-2.0.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c1c91405fcf1d501fa5d55df21e58ea49e6b879ae829f1039faaf7e5e509b41e", size = 150325, upload-time = "2025-11-07T00:44:29.29Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/b6/20ffcf2558596a7f58a2e69c89597128781f0b88e124bf5a4cadc05b8139/wrapt-2.0.1-cp313-cp313t-win32.whl", hash = "sha256:e76e3f91f864e89db8b8d2a8311d57df93f01ad6bb1e9b9976d1f2e83e18315c", size = 59943, upload-time = "2025-11-07T00:44:33.211Z" },
+    { url = "https://files.pythonhosted.org/packages/87/6a/0e56111cbb3320151eed5d3821ee1373be13e05b376ea0870711f18810c3/wrapt-2.0.1-cp313-cp313t-win_amd64.whl", hash = "sha256:83ce30937f0ba0d28818807b303a412440c4b63e39d3d8fc036a94764b728c92", size = 63240, upload-time = "2025-11-07T00:44:30.935Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/54/5ab4c53ea1f7f7e5c3e7c1095db92932cc32fd62359d285486d00c2884c3/wrapt-2.0.1-cp313-cp313t-win_arm64.whl", hash = "sha256:4b55cacc57e1dc2d0991dbe74c6419ffd415fb66474a02335cb10efd1aa3f84f", size = 60416, upload-time = "2025-11-07T00:44:32.002Z" },
+    { url = "https://files.pythonhosted.org/packages/15/d1/b51471c11592ff9c012bd3e2f7334a6ff2f42a7aed2caffcf0bdddc9cb89/wrapt-2.0.1-py3-none-any.whl", hash = "sha256:4d2ce1bf1a48c5277d7969259232b57645aae5686dba1eaeade39442277afbca", size = 44046, upload-time = "2025-11-07T00:45:32.116Z" },
+]
+
+[[package]]
+name = "xxhash"
+version = "3.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/02/84/30869e01909fb37a6cc7e18688ee8bf1e42d57e7e0777636bd47524c43c7/xxhash-3.6.0.tar.gz", hash = "sha256:f0162a78b13a0d7617b2845b90c763339d1f1d82bb04a4b07f4ab535cc5e05d6", size = 85160, upload-time = "2025-10-02T14:37:08.097Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/34/ee/f9f1d656ad168681bb0f6b092372c1e533c4416b8069b1896a175c46e484/xxhash-3.6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:87ff03d7e35c61435976554477a7f4cd1704c3596a89a8300d5ce7fc83874a71", size = 32845, upload-time = "2025-10-02T14:33:51.573Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/b1/93508d9460b292c74a09b83d16750c52a0ead89c51eea9951cb97a60d959/xxhash-3.6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f572dfd3d0e2eb1a57511831cf6341242f5a9f8298a45862d085f5b93394a27d", size = 30807, upload-time = "2025-10-02T14:33:52.964Z" },
+    { url = "https://files.pythonhosted.org/packages/07/55/28c93a3662f2d200c70704efe74aab9640e824f8ce330d8d3943bf7c9b3c/xxhash-3.6.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:89952ea539566b9fed2bbd94e589672794b4286f342254fad28b149f9615fef8", size = 193786, upload-time = "2025-10-02T14:33:54.272Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/96/fec0be9bb4b8f5d9c57d76380a366f31a1781fb802f76fc7cda6c84893c7/xxhash-3.6.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e6f2ffb07a50b52465a1032c3cf1f4a5683f944acaca8a134a2f23674c2058", size = 212830, upload-time = "2025-10-02T14:33:55.706Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/a0/c706845ba77b9611f81fd2e93fad9859346b026e8445e76f8c6fd057cc6d/xxhash-3.6.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b5b848ad6c16d308c3ac7ad4ba6bede80ed5df2ba8ed382f8932df63158dd4b2", size = 211606, upload-time = "2025-10-02T14:33:57.133Z" },
+    { url = "https://files.pythonhosted.org/packages/67/1e/164126a2999e5045f04a69257eea946c0dc3e86541b400d4385d646b53d7/xxhash-3.6.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a034590a727b44dd8ac5914236a7b8504144447a9682586c3327e935f33ec8cc", size = 444872, upload-time = "2025-10-02T14:33:58.446Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/4b/55ab404c56cd70a2cf5ecfe484838865d0fea5627365c6c8ca156bd09c8f/xxhash-3.6.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a8f1972e75ebdd161d7896743122834fe87378160c20e97f8b09166213bf8cc", size = 193217, upload-time = "2025-10-02T14:33:59.724Z" },
+    { url = "https://files.pythonhosted.org/packages/45/e6/52abf06bac316db33aa269091ae7311bd53cfc6f4b120ae77bac1b348091/xxhash-3.6.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ee34327b187f002a596d7b167ebc59a1b729e963ce645964bbc050d2f1b73d07", size = 210139, upload-time = "2025-10-02T14:34:02.041Z" },
+    { url = "https://files.pythonhosted.org/packages/34/37/db94d490b8691236d356bc249c08819cbcef9273a1a30acf1254ff9ce157/xxhash-3.6.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:339f518c3c7a850dd033ab416ea25a692759dc7478a71131fe8869010d2b75e4", size = 197669, upload-time = "2025-10-02T14:34:03.664Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/36/c4f219ef4a17a4f7a64ed3569bc2b5a9c8311abdb22249ac96093625b1a4/xxhash-3.6.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:bf48889c9630542d4709192578aebbd836177c9f7a4a2778a7d6340107c65f06", size = 210018, upload-time = "2025-10-02T14:34:05.325Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/06/bfac889a374fc2fc439a69223d1750eed2e18a7db8514737ab630534fa08/xxhash-3.6.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:5576b002a56207f640636056b4160a378fe36a58db73ae5c27a7ec8db35f71d4", size = 413058, upload-time = "2025-10-02T14:34:06.925Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d1/555d8447e0dd32ad0930a249a522bb2e289f0d08b6b16204cfa42c1f5a0c/xxhash-3.6.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:af1f3278bd02814d6dedc5dec397993b549d6f16c19379721e5a1d31e132c49b", size = 190628, upload-time = "2025-10-02T14:34:08.669Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/15/8751330b5186cedc4ed4b597989882ea05e0408b53fa47bcb46a6125bfc6/xxhash-3.6.0-cp310-cp310-win32.whl", hash = "sha256:aed058764db109dc9052720da65fafe84873b05eb8b07e5e653597951af57c3b", size = 30577, upload-time = "2025-10-02T14:34:10.234Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/cc/53f87e8b5871a6eb2ff7e89c48c66093bda2be52315a8161ddc54ea550c4/xxhash-3.6.0-cp310-cp310-win_amd64.whl", hash = "sha256:e82da5670f2d0d98950317f82a0e4a0197150ff19a6df2ba40399c2a3b9ae5fb", size = 31487, upload-time = "2025-10-02T14:34:11.618Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/00/60f9ea3bb697667a14314d7269956f58bf56bb73864f8f8d52a3c2535e9a/xxhash-3.6.0-cp310-cp310-win_arm64.whl", hash = "sha256:4a082ffff8c6ac07707fb6b671caf7c6e020c75226c561830b73d862060f281d", size = 27863, upload-time = "2025-10-02T14:34:12.619Z" },
+    { url = "https://files.pythonhosted.org/packages/17/d4/cc2f0400e9154df4b9964249da78ebd72f318e35ccc425e9f403c392f22a/xxhash-3.6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b47bbd8cf2d72797f3c2772eaaac0ded3d3af26481a26d7d7d41dc2d3c46b04a", size = 32844, upload-time = "2025-10-02T14:34:14.037Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/ec/1cc11cd13e26ea8bc3cb4af4eaadd8d46d5014aebb67be3f71fb0b68802a/xxhash-3.6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2b6821e94346f96db75abaa6e255706fb06ebd530899ed76d32cd99f20dc52fa", size = 30809, upload-time = "2025-10-02T14:34:15.484Z" },
+    { url = "https://files.pythonhosted.org/packages/04/5f/19fe357ea348d98ca22f456f75a30ac0916b51c753e1f8b2e0e6fb884cce/xxhash-3.6.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d0a9751f71a1a65ce3584e9cae4467651c7e70c9d31017fa57574583a4540248", size = 194665, upload-time = "2025-10-02T14:34:16.541Z" },
+    { url = "https://files.pythonhosted.org/packages/90/3b/d1f1a8f5442a5fd8beedae110c5af7604dc37349a8e16519c13c19a9a2de/xxhash-3.6.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b29ee68625ab37b04c0b40c3fafdf24d2f75ccd778333cfb698f65f6c463f62", size = 213550, upload-time = "2025-10-02T14:34:17.878Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ef/3a9b05eb527457d5db13a135a2ae1a26c80fecd624d20f3e8dcc4cb170f3/xxhash-3.6.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6812c25fe0d6c36a46ccb002f40f27ac903bf18af9f6dd8f9669cb4d176ab18f", size = 212384, upload-time = "2025-10-02T14:34:19.182Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/18/ccc194ee698c6c623acbf0f8c2969811a8a4b6185af5e824cd27b9e4fd3e/xxhash-3.6.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4ccbff013972390b51a18ef1255ef5ac125c92dc9143b2d1909f59abc765540e", size = 445749, upload-time = "2025-10-02T14:34:20.659Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/86/cf2c0321dc3940a7aa73076f4fd677a0fb3e405cb297ead7d864fd90847e/xxhash-3.6.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:297b7fbf86c82c550e12e8fb71968b3f033d27b874276ba3624ea868c11165a8", size = 193880, upload-time = "2025-10-02T14:34:22.431Z" },
+    { url = "https://files.pythonhosted.org/packages/82/fb/96213c8560e6f948a1ecc9a7613f8032b19ee45f747f4fca4eb31bb6d6ed/xxhash-3.6.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dea26ae1eb293db089798d3973a5fc928a18fdd97cc8801226fae705b02b14b0", size = 210912, upload-time = "2025-10-02T14:34:23.937Z" },
+    { url = "https://files.pythonhosted.org/packages/40/aa/4395e669b0606a096d6788f40dbdf2b819d6773aa290c19e6e83cbfc312f/xxhash-3.6.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:7a0b169aafb98f4284f73635a8e93f0735f9cbde17bd5ec332480484241aaa77", size = 198654, upload-time = "2025-10-02T14:34:25.644Z" },
+    { url = "https://files.pythonhosted.org/packages/67/74/b044fcd6b3d89e9b1b665924d85d3f400636c23590226feb1eb09e1176ce/xxhash-3.6.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:08d45aef063a4531b785cd72de4887766d01dc8f362a515693df349fdb825e0c", size = 210867, upload-time = "2025-10-02T14:34:27.203Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/fd/3ce73bf753b08cb19daee1eb14aa0d7fe331f8da9c02dd95316ddfe5275e/xxhash-3.6.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:929142361a48ee07f09121fe9e96a84950e8d4df3bb298ca5d88061969f34d7b", size = 414012, upload-time = "2025-10-02T14:34:28.409Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/b3/5a4241309217c5c876f156b10778f3ab3af7ba7e3259e6d5f5c7d0129eb2/xxhash-3.6.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:51312c768403d8540487dbbfb557454cfc55589bbde6424456951f7fcd4facb3", size = 191409, upload-time = "2025-10-02T14:34:29.696Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/99bfbc15fb9abb9a72b088c1d95219fc4782b7d01fc835bd5744d66dd0b8/xxhash-3.6.0-cp311-cp311-win32.whl", hash = "sha256:d1927a69feddc24c987b337ce81ac15c4720955b667fe9b588e02254b80446fd", size = 30574, upload-time = "2025-10-02T14:34:31.028Z" },
+    { url = "https://files.pythonhosted.org/packages/65/79/9d24d7f53819fe301b231044ea362ce64e86c74f6e8c8e51320de248b3e5/xxhash-3.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:26734cdc2d4ffe449b41d186bbeac416f704a482ed835d375a5c0cb02bc63fef", size = 31481, upload-time = "2025-10-02T14:34:32.062Z" },
+    { url = "https://files.pythonhosted.org/packages/30/4e/15cd0e3e8772071344eab2961ce83f6e485111fed8beb491a3f1ce100270/xxhash-3.6.0-cp311-cp311-win_arm64.whl", hash = "sha256:d72f67ef8bf36e05f5b6c65e8524f265bd61071471cd4cf1d36743ebeeeb06b7", size = 27861, upload-time = "2025-10-02T14:34:33.555Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/07/d9412f3d7d462347e4511181dea65e47e0d0e16e26fbee2ea86a2aefb657/xxhash-3.6.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:01362c4331775398e7bb34e3ab403bc9ee9f7c497bc7dee6272114055277dd3c", size = 32744, upload-time = "2025-10-02T14:34:34.622Z" },
+    { url = "https://files.pythonhosted.org/packages/79/35/0429ee11d035fc33abe32dca1b2b69e8c18d236547b9a9b72c1929189b9a/xxhash-3.6.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b7b2df81a23f8cb99656378e72501b2cb41b1827c0f5a86f87d6b06b69f9f204", size = 30816, upload-time = "2025-10-02T14:34:36.043Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/f2/57eb99aa0f7d98624c0932c5b9a170e1806406cdbcdb510546634a1359e0/xxhash-3.6.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:dc94790144e66b14f67b10ac8ed75b39ca47536bf8800eb7c24b50271ea0c490", size = 194035, upload-time = "2025-10-02T14:34:37.354Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/ed/6224ba353690d73af7a3f1c7cdb1fc1b002e38f783cb991ae338e1eb3d79/xxhash-3.6.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:93f107c673bccf0d592cdba077dedaf52fe7f42dcd7676eba1f6d6f0c3efffd2", size = 212914, upload-time = "2025-10-02T14:34:38.6Z" },
+    { url = "https://files.pythonhosted.org/packages/38/86/fb6b6130d8dd6b8942cc17ab4d90e223653a89aa32ad2776f8af7064ed13/xxhash-3.6.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2aa5ee3444c25b69813663c9f8067dcfaa2e126dc55e8dddf40f4d1c25d7effa", size = 212163, upload-time = "2025-10-02T14:34:39.872Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/dc/e84875682b0593e884ad73b2d40767b5790d417bde603cceb6878901d647/xxhash-3.6.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f7f99123f0e1194fa59cc69ad46dbae2e07becec5df50a0509a808f90a0f03f0", size = 445411, upload-time = "2025-10-02T14:34:41.569Z" },
+    { url = "https://files.pythonhosted.org/packages/11/4f/426f91b96701ec2f37bb2b8cec664eff4f658a11f3fa9d94f0a887ea6d2b/xxhash-3.6.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:49e03e6fe2cac4a1bc64952dd250cf0dbc5ef4ebb7b8d96bce82e2de163c82a2", size = 193883, upload-time = "2025-10-02T14:34:43.249Z" },
+    { url = "https://files.pythonhosted.org/packages/53/5a/ddbb83eee8e28b778eacfc5a85c969673e4023cdeedcfcef61f36731610b/xxhash-3.6.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bd17fede52a17a4f9a7bc4472a5867cb0b160deeb431795c0e4abe158bc784e9", size = 210392, upload-time = "2025-10-02T14:34:45.042Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/c2/ff69efd07c8c074ccdf0a4f36fcdd3d27363665bcdf4ba399abebe643465/xxhash-3.6.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:6fb5f5476bef678f69db04f2bd1efbed3030d2aba305b0fc1773645f187d6a4e", size = 197898, upload-time = "2025-10-02T14:34:46.302Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ca/faa05ac19b3b622c7c9317ac3e23954187516298a091eb02c976d0d3dd45/xxhash-3.6.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:843b52f6d88071f87eba1631b684fcb4b2068cd2180a0224122fe4ef011a9374", size = 210655, upload-time = "2025-10-02T14:34:47.571Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/7a/06aa7482345480cc0cb597f5c875b11a82c3953f534394f620b0be2f700c/xxhash-3.6.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7d14a6cfaf03b1b6f5f9790f76880601ccc7896aff7ab9cd8978a939c1eb7e0d", size = 414001, upload-time = "2025-10-02T14:34:49.273Z" },
+    { url = "https://files.pythonhosted.org/packages/23/07/63ffb386cd47029aa2916b3d2f454e6cc5b9f5c5ada3790377d5430084e7/xxhash-3.6.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:418daf3db71e1413cfe211c2f9a528456936645c17f46b5204705581a45390ae", size = 191431, upload-time = "2025-10-02T14:34:50.798Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/93/14fde614cadb4ddf5e7cebf8918b7e8fac5ae7861c1875964f17e678205c/xxhash-3.6.0-cp312-cp312-win32.whl", hash = "sha256:50fc255f39428a27299c20e280d6193d8b63b8ef8028995323bf834a026b4fbb", size = 30617, upload-time = "2025-10-02T14:34:51.954Z" },
+    { url = "https://files.pythonhosted.org/packages/13/5d/0d125536cbe7565a83d06e43783389ecae0c0f2ed037b48ede185de477c0/xxhash-3.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:c0f2ab8c715630565ab8991b536ecded9416d615538be8ecddce43ccf26cbc7c", size = 31534, upload-time = "2025-10-02T14:34:53.276Z" },
+    { url = "https://files.pythonhosted.org/packages/54/85/6ec269b0952ec7e36ba019125982cf11d91256a778c7c3f98a4c5043d283/xxhash-3.6.0-cp312-cp312-win_arm64.whl", hash = "sha256:eae5c13f3bc455a3bbb68bdc513912dc7356de7e2280363ea235f71f54064829", size = 27876, upload-time = "2025-10-02T14:34:54.371Z" },
+    { url = "https://files.pythonhosted.org/packages/33/76/35d05267ac82f53ae9b0e554da7c5e281ee61f3cad44c743f0fcd354f211/xxhash-3.6.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:599e64ba7f67472481ceb6ee80fa3bd828fd61ba59fb11475572cc5ee52b89ec", size = 32738, upload-time = "2025-10-02T14:34:55.839Z" },
+    { url = "https://files.pythonhosted.org/packages/31/a8/3fbce1cd96534a95e35d5120637bf29b0d7f5d8fa2f6374e31b4156dd419/xxhash-3.6.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7d8b8aaa30fca4f16f0c84a5c8d7ddee0e25250ec2796c973775373257dde8f1", size = 30821, upload-time = "2025-10-02T14:34:57.219Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ea/d387530ca7ecfa183cb358027f1833297c6ac6098223fd14f9782cd0015c/xxhash-3.6.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d597acf8506d6e7101a4a44a5e428977a51c0fadbbfd3c39650cca9253f6e5a6", size = 194127, upload-time = "2025-10-02T14:34:59.21Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/0c/71435dcb99874b09a43b8d7c54071e600a7481e42b3e3ce1eb5226a5711a/xxhash-3.6.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:858dc935963a33bc33490128edc1c12b0c14d9c7ebaa4e387a7869ecc4f3e263", size = 212975, upload-time = "2025-10-02T14:35:00.816Z" },
+    { url = "https://files.pythonhosted.org/packages/84/7a/c2b3d071e4bb4a90b7057228a99b10d51744878f4a8a6dd643c8bd897620/xxhash-3.6.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba284920194615cb8edf73bf52236ce2e1664ccd4a38fdb543506413529cc546", size = 212241, upload-time = "2025-10-02T14:35:02.207Z" },
+    { url = "https://files.pythonhosted.org/packages/81/5f/640b6eac0128e215f177df99eadcd0f1b7c42c274ab6a394a05059694c5a/xxhash-3.6.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b54219177f6c6674d5378bd862c6aedf64725f70dd29c472eaae154df1a2e89", size = 445471, upload-time = "2025-10-02T14:35:03.61Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/1e/3c3d3ef071b051cc3abbe3721ffb8365033a172613c04af2da89d5548a87/xxhash-3.6.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42c36dd7dbad2f5238950c377fcbf6811b1cdb1c444fab447960030cea60504d", size = 193936, upload-time = "2025-10-02T14:35:05.013Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/bd/4a5f68381939219abfe1c22a9e3a5854a4f6f6f3c4983a87d255f21f2e5d/xxhash-3.6.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f22927652cba98c44639ffdc7aaf35828dccf679b10b31c4ad72a5b530a18eb7", size = 210440, upload-time = "2025-10-02T14:35:06.239Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/37/b80fe3d5cfb9faff01a02121a0f4d565eb7237e9e5fc66e73017e74dcd36/xxhash-3.6.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b45fad44d9c5c119e9c6fbf2e1c656a46dc68e280275007bbfd3d572b21426db", size = 197990, upload-time = "2025-10-02T14:35:07.735Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/fd/2c0a00c97b9e18f72e1f240ad4e8f8a90fd9d408289ba9c7c495ed7dc05c/xxhash-3.6.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:6f2580ffab1a8b68ef2b901cde7e55fa8da5e4be0977c68f78fc80f3c143de42", size = 210689, upload-time = "2025-10-02T14:35:09.438Z" },
+    { url = "https://files.pythonhosted.org/packages/93/86/5dd8076a926b9a95db3206aba20d89a7fc14dd5aac16e5c4de4b56033140/xxhash-3.6.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40c391dd3cd041ebc3ffe6f2c862f402e306eb571422e0aa918d8070ba31da11", size = 414068, upload-time = "2025-10-02T14:35:11.162Z" },
+    { url = "https://files.pythonhosted.org/packages/af/3c/0bb129170ee8f3650f08e993baee550a09593462a5cddd8e44d0011102b1/xxhash-3.6.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f205badabde7aafd1a31e8ca2a3e5a763107a71c397c4481d6a804eb5063d8bd", size = 191495, upload-time = "2025-10-02T14:35:12.971Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/3a/6797e0114c21d1725e2577508e24006fd7ff1d8c0c502d3b52e45c1771d8/xxhash-3.6.0-cp313-cp313-win32.whl", hash = "sha256:2577b276e060b73b73a53042ea5bd5203d3e6347ce0d09f98500f418a9fcf799", size = 30620, upload-time = "2025-10-02T14:35:14.129Z" },
+    { url = "https://files.pythonhosted.org/packages/86/15/9bc32671e9a38b413a76d24722a2bf8784a132c043063a8f5152d390b0f9/xxhash-3.6.0-cp313-cp313-win_amd64.whl", hash = "sha256:757320d45d2fbcce8f30c42a6b2f47862967aea7bf458b9625b4bbe7ee390392", size = 31542, upload-time = "2025-10-02T14:35:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/39/c5/cc01e4f6188656e56112d6a8e0dfe298a16934b8c47a247236549a3f7695/xxhash-3.6.0-cp313-cp313-win_arm64.whl", hash = "sha256:457b8f85dec5825eed7b69c11ae86834a018b8e3df5e77783c999663da2f96d6", size = 27880, upload-time = "2025-10-02T14:35:16.315Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/30/25e5321c8732759e930c555176d37e24ab84365482d257c3b16362235212/xxhash-3.6.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a42e633d75cdad6d625434e3468126c73f13f7584545a9cf34e883aa1710e702", size = 32956, upload-time = "2025-10-02T14:35:17.413Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/3c/0573299560d7d9f8ab1838f1efc021a280b5ae5ae2e849034ef3dee18810/xxhash-3.6.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:568a6d743219e717b07b4e03b0a828ce593833e498c3b64752e0f5df6bfe84db", size = 31072, upload-time = "2025-10-02T14:35:18.844Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1c/52d83a06e417cd9d4137722693424885cc9878249beb3a7c829e74bf7ce9/xxhash-3.6.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bec91b562d8012dae276af8025a55811b875baace6af510412a5e58e3121bc54", size = 196409, upload-time = "2025-10-02T14:35:20.31Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/8e/c6d158d12a79bbd0b878f8355432075fc82759e356ab5a111463422a239b/xxhash-3.6.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78e7f2f4c521c30ad5e786fdd6bae89d47a32672a80195467b5de0480aa97b1f", size = 215736, upload-time = "2025-10-02T14:35:21.616Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/68/c4c80614716345d55071a396cf03d06e34b5f4917a467faf43083c995155/xxhash-3.6.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3ed0df1b11a79856df5ffcab572cbd6b9627034c1c748c5566fa79df9048a7c5", size = 214833, upload-time = "2025-10-02T14:35:23.32Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/e9/ae27c8ffec8b953efa84c7c4a6c6802c263d587b9fc0d6e7cea64e08c3af/xxhash-3.6.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0e4edbfc7d420925b0dd5e792478ed393d6e75ff8fc219a6546fb446b6a417b1", size = 448348, upload-time = "2025-10-02T14:35:25.111Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/6b/33e21afb1b5b3f46b74b6bd1913639066af218d704cc0941404ca717fc57/xxhash-3.6.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fba27a198363a7ef87f8c0f6b171ec36b674fe9053742c58dd7e3201c1ab30ee", size = 196070, upload-time = "2025-10-02T14:35:26.586Z" },
+    { url = "https://files.pythonhosted.org/packages/96/b6/fcabd337bc5fa624e7203aa0fa7d0c49eed22f72e93229431752bddc83d9/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:794fe9145fe60191c6532fa95063765529770edcdd67b3d537793e8004cabbfd", size = 212907, upload-time = "2025-10-02T14:35:28.087Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/d3/9ee6160e644d660fcf176c5825e61411c7f62648728f69c79ba237250143/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:6105ef7e62b5ac73a837778efc331a591d8442f8ef5c7e102376506cb4ae2729", size = 200839, upload-time = "2025-10-02T14:35:29.857Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/98/e8de5baa5109394baf5118f5e72ab21a86387c4f89b0e77ef3e2f6b0327b/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:f01375c0e55395b814a679b3eea205db7919ac2af213f4a6682e01220e5fe292", size = 213304, upload-time = "2025-10-02T14:35:31.222Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/1d/71056535dec5c3177eeb53e38e3d367dd1d16e024e63b1cee208d572a033/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:d706dca2d24d834a4661619dcacf51a75c16d65985718d6a7d73c1eeeb903ddf", size = 416930, upload-time = "2025-10-02T14:35:32.517Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/6c/5cbde9de2cd967c322e651c65c543700b19e7ae3e0aae8ece3469bf9683d/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5f059d9faeacd49c0215d66f4056e1326c80503f51a1532ca336a385edadd033", size = 193787, upload-time = "2025-10-02T14:35:33.827Z" },
+    { url = "https://files.pythonhosted.org/packages/19/fa/0172e350361d61febcea941b0cc541d6e6c8d65d153e85f850a7b256ff8a/xxhash-3.6.0-cp313-cp313t-win32.whl", hash = "sha256:1244460adc3a9be84731d72b8e80625788e5815b68da3da8b83f78115a40a7ec", size = 30916, upload-time = "2025-10-02T14:35:35.107Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/e6/e8cf858a2b19d6d45820f072eff1bea413910592ff17157cabc5f1227a16/xxhash-3.6.0-cp313-cp313t-win_amd64.whl", hash = "sha256:b1e420ef35c503869c4064f4a2f2b08ad6431ab7b229a05cce39d74268bca6b8", size = 31799, upload-time = "2025-10-02T14:35:36.165Z" },
+    { url = "https://files.pythonhosted.org/packages/56/15/064b197e855bfb7b343210e82490ae672f8bc7cdf3ddb02e92f64304ee8a/xxhash-3.6.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ec44b73a4220623235f67a996c862049f375df3b1052d9899f40a6382c32d746", size = 28044, upload-time = "2025-10-02T14:35:37.195Z" },
+    { url = "https://files.pythonhosted.org/packages/93/1e/8aec23647a34a249f62e2398c42955acd9b4c6ed5cf08cbea94dc46f78d2/xxhash-3.6.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0f7b7e2ec26c1666ad5fc9dbfa426a6a3367ceaf79db5dd76264659d509d73b0", size = 30662, upload-time = "2025-10-02T14:37:01.743Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/0b/b14510b38ba91caf43006209db846a696ceea6a847a0c9ba0a5b1adc53d6/xxhash-3.6.0-pp311-pypy311_pp73-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5dc1e14d14fa0f5789ec29a7062004b5933964bb9b02aae6622b8f530dc40296", size = 41056, upload-time = "2025-10-02T14:37:02.879Z" },
+    { url = "https://files.pythonhosted.org/packages/50/55/15a7b8a56590e66ccd374bbfa3f9ffc45b810886c8c3b614e3f90bd2367c/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:881b47fc47e051b37d94d13e7455131054b56749b91b508b0907eb07900d1c13", size = 36251, upload-time = "2025-10-02T14:37:04.44Z" },
+    { url = "https://files.pythonhosted.org/packages/62/b2/5ac99a041a29e58e95f907876b04f7067a0242cb85b5f39e726153981503/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6dc31591899f5e5666f04cc2e529e69b4072827085c1ef15294d91a004bc1bd", size = 32481, upload-time = "2025-10-02T14:37:05.869Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/d9/8d95e906764a386a3d3b596f3c68bb63687dfca806373509f51ce8eea81f/xxhash-3.6.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:15e0dac10eb9309508bfc41f7f9deaa7755c69e35af835db9cb10751adebc35d", size = 31565, upload-time = "2025-10-02T14:37:06.966Z" },
+]
+
+[[package]]
+name = "yourdfpy"
+version = "0.0.58"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "lxml" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' or (extra == 'extra-5-mjlab-cpu' and extra == 'extra-5-mjlab-cu128')" },
+    { name = "six" },
+    { name = "trimesh", extra = ["easy"] },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/dc/c5/1f9199dc6fe2599fcd85c9dc52fa83381d9efd3a0b13e810fbbf2587155b/yourdfpy-0.0.58.tar.gz", hash = "sha256:68d23688802c8e23843a8981f828bcca9a7875cdb02be7f3a0e67b42929727f3", size = 538217, upload-time = "2025-06-24T17:05:14.177Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/e1/ab7086ffc2767455a28848945ddacce1533d67ad26c20a4a01c93d0ea239/yourdfpy-0.0.58-py3-none-any.whl", hash = "sha256:9e1b00ef0d33256d8d0f3a48e34ebf28a05181cee7f6c44a32c704a0261aa9c0", size = 22176, upload-time = "2025-06-24T17:05:12.95Z" },
+]
+
+[[package]]
+name = "zipp"
+version = "3.23.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
+]
+
+[[package]]
+name = "zstandard"
+version = "0.25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/aa/3e0508d5a5dd96529cdc5a97011299056e14c6505b678fd58938792794b1/zstandard-0.25.0.tar.gz", hash = "sha256:7713e1179d162cf5c7906da876ec2ccb9c3a9dcbdffef0cc7f70c3667a205f0b", size = 711513, upload-time = "2025-09-14T22:15:54.002Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/56/7a/28efd1d371f1acd037ac64ed1c5e2b41514a6cc937dd6ab6a13ab9f0702f/zstandard-0.25.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e59fdc271772f6686e01e1b3b74537259800f57e24280be3f29c8a0deb1904dd", size = 795256, upload-time = "2025-09-14T22:15:56.415Z" },
+    { url = "https://files.pythonhosted.org/packages/96/34/ef34ef77f1ee38fc8e4f9775217a613b452916e633c4f1d98f31db52c4a5/zstandard-0.25.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4d441506e9b372386a5271c64125f72d5df6d2a8e8a2a45a0ae09b03cb781ef7", size = 640565, upload-time = "2025-09-14T22:15:58.177Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/1b/4fdb2c12eb58f31f28c4d28e8dc36611dd7205df8452e63f52fb6261d13e/zstandard-0.25.0-cp310-cp310-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:ab85470ab54c2cb96e176f40342d9ed41e58ca5733be6a893b730e7af9c40550", size = 5345306, upload-time = "2025-09-14T22:16:00.165Z" },
+    { url = "https://files.pythonhosted.org/packages/73/28/a44bdece01bca027b079f0e00be3b6bd89a4df180071da59a3dd7381665b/zstandard-0.25.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e05ab82ea7753354bb054b92e2f288afb750e6b439ff6ca78af52939ebbc476d", size = 5055561, upload-time = "2025-09-14T22:16:02.22Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/74/68341185a4f32b274e0fc3410d5ad0750497e1acc20bd0f5b5f64ce17785/zstandard-0.25.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:78228d8a6a1c177a96b94f7e2e8d012c55f9c760761980da16ae7546a15a8e9b", size = 5402214, upload-time = "2025-09-14T22:16:04.109Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/67/f92e64e748fd6aaffe01e2b75a083c0c4fd27abe1c8747fee4555fcee7dd/zstandard-0.25.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:2b6bd67528ee8b5c5f10255735abc21aa106931f0dbaf297c7be0c886353c3d0", size = 5449703, upload-time = "2025-09-14T22:16:06.312Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e5/6d36f92a197c3c17729a2125e29c169f460538a7d939a27eaaa6dcfcba8e/zstandard-0.25.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4b6d83057e713ff235a12e73916b6d356e3084fd3d14ced499d84240f3eecee0", size = 5556583, upload-time = "2025-09-14T22:16:08.457Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/83/41939e60d8d7ebfe2b747be022d0806953799140a702b90ffe214d557638/zstandard-0.25.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:9174f4ed06f790a6869b41cba05b43eeb9a35f8993c4422ab853b705e8112bbd", size = 5045332, upload-time = "2025-09-14T22:16:10.444Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/87/d3ee185e3d1aa0133399893697ae91f221fda79deb61adbe998a7235c43f/zstandard-0.25.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:25f8f3cd45087d089aef5ba3848cd9efe3ad41163d3400862fb42f81a3a46701", size = 5572283, upload-time = "2025-09-14T22:16:12.128Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/1d/58635ae6104df96671076ac7d4ae7816838ce7debd94aecf83e30b7121b0/zstandard-0.25.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3756b3e9da9b83da1796f8809dd57cb024f838b9eeafde28f3cb472012797ac1", size = 4959754, upload-time = "2025-09-14T22:16:14.225Z" },
+    { url = "https://files.pythonhosted.org/packages/75/d6/57e9cb0a9983e9a229dd8fd2e6e96593ef2aa82a3907188436f22b111ccd/zstandard-0.25.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:81dad8d145d8fd981b2962b686b2241d3a1ea07733e76a2f15435dfb7fb60150", size = 5266477, upload-time = "2025-09-14T22:16:16.343Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/a9/ee891e5edf33a6ebce0a028726f0bbd8567effe20fe3d5808c42323e8542/zstandard-0.25.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:a5a419712cf88862a45a23def0ae063686db3d324cec7edbe40509d1a79a0aab", size = 5440914, upload-time = "2025-09-14T22:16:18.453Z" },
+    { url = "https://files.pythonhosted.org/packages/58/08/a8522c28c08031a9521f27abc6f78dbdee7312a7463dd2cfc658b813323b/zstandard-0.25.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e7360eae90809efd19b886e59a09dad07da4ca9ba096752e61a2e03c8aca188e", size = 5819847, upload-time = "2025-09-14T22:16:20.559Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/11/4c91411805c3f7b6f31c60e78ce347ca48f6f16d552fc659af6ec3b73202/zstandard-0.25.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:75ffc32a569fb049499e63ce68c743155477610532da1eb38e7f24bf7cd29e74", size = 5363131, upload-time = "2025-09-14T22:16:22.206Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/d6/8c4bd38a3b24c4c7676a7a3d8de85d6ee7a983602a734b9f9cdefb04a5d6/zstandard-0.25.0-cp310-cp310-win32.whl", hash = "sha256:106281ae350e494f4ac8a80470e66d1fe27e497052c8d9c3b95dc4cf1ade81aa", size = 436469, upload-time = "2025-09-14T22:16:25.002Z" },
+    { url = "https://files.pythonhosted.org/packages/93/90/96d50ad417a8ace5f841b3228e93d1bb13e6ad356737f42e2dde30d8bd68/zstandard-0.25.0-cp310-cp310-win_amd64.whl", hash = "sha256:ea9d54cc3d8064260114a0bbf3479fc4a98b21dffc89b3459edd506b69262f6e", size = 506100, upload-time = "2025-09-14T22:16:23.569Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/83/c3ca27c363d104980f1c9cee1101cc8ba724ac8c28a033ede6aab89585b1/zstandard-0.25.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:933b65d7680ea337180733cf9e87293cc5500cc0eb3fc8769f4d3c88d724ec5c", size = 795254, upload-time = "2025-09-14T22:16:26.137Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/4d/e66465c5411a7cf4866aeadc7d108081d8ceba9bc7abe6b14aa21c671ec3/zstandard-0.25.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3f79487c687b1fc69f19e487cd949bf3aae653d181dfb5fde3bf6d18894706f", size = 640559, upload-time = "2025-09-14T22:16:27.973Z" },
+    { url = "https://files.pythonhosted.org/packages/12/56/354fe655905f290d3b147b33fe946b0f27e791e4b50a5f004c802cb3eb7b/zstandard-0.25.0-cp311-cp311-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:0bbc9a0c65ce0eea3c34a691e3c4b6889f5f3909ba4822ab385fab9057099431", size = 5348020, upload-time = "2025-09-14T22:16:29.523Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/13/2b7ed68bd85e69a2069bcc72141d378f22cae5a0f3b353a2c8f50ef30c1b/zstandard-0.25.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:01582723b3ccd6939ab7b3a78622c573799d5d8737b534b86d0e06ac18dbde4a", size = 5058126, upload-time = "2025-09-14T22:16:31.811Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/dd/fdaf0674f4b10d92cb120ccff58bbb6626bf8368f00ebfd2a41ba4a0dc99/zstandard-0.25.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5f1ad7bf88535edcf30038f6919abe087f606f62c00a87d7e33e7fc57cb69fcc", size = 5405390, upload-time = "2025-09-14T22:16:33.486Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/67/354d1555575bc2490435f90d67ca4dd65238ff2f119f30f72d5cde09c2ad/zstandard-0.25.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:06acb75eebeedb77b69048031282737717a63e71e4ae3f77cc0c3b9508320df6", size = 5452914, upload-time = "2025-09-14T22:16:35.277Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/1f/e9cfd801a3f9190bf3e759c422bbfd2247db9d7f3d54a56ecde70137791a/zstandard-0.25.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9300d02ea7c6506f00e627e287e0492a5eb0371ec1670ae852fefffa6164b072", size = 5559635, upload-time = "2025-09-14T22:16:37.141Z" },
+    { url = "https://files.pythonhosted.org/packages/21/88/5ba550f797ca953a52d708c8e4f380959e7e3280af029e38fbf47b55916e/zstandard-0.25.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:bfd06b1c5584b657a2892a6014c2f4c20e0db0208c159148fa78c65f7e0b0277", size = 5048277, upload-time = "2025-09-14T22:16:38.807Z" },
+    { url = "https://files.pythonhosted.org/packages/46/c0/ca3e533b4fa03112facbe7fbe7779cb1ebec215688e5df576fe5429172e0/zstandard-0.25.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f373da2c1757bb7f1acaf09369cdc1d51d84131e50d5fa9863982fd626466313", size = 5574377, upload-time = "2025-09-14T22:16:40.523Z" },
+    { url = "https://files.pythonhosted.org/packages/12/9b/3fb626390113f272abd0799fd677ea33d5fc3ec185e62e6be534493c4b60/zstandard-0.25.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6c0e5a65158a7946e7a7affa6418878ef97ab66636f13353b8502d7ea03c8097", size = 4961493, upload-time = "2025-09-14T22:16:43.3Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/d3/23094a6b6a4b1343b27ae68249daa17ae0651fcfec9ed4de09d14b940285/zstandard-0.25.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:c8e167d5adf59476fa3e37bee730890e389410c354771a62e3c076c86f9f7778", size = 5269018, upload-time = "2025-09-14T22:16:45.292Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/a7/bb5a0c1c0f3f4b5e9d5b55198e39de91e04ba7c205cc46fcb0f95f0383c1/zstandard-0.25.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:98750a309eb2f020da61e727de7d7ba3c57c97cf6213f6f6277bb7fb42a8e065", size = 5443672, upload-time = "2025-09-14T22:16:47.076Z" },
+    { url = "https://files.pythonhosted.org/packages/27/22/503347aa08d073993f25109c36c8d9f029c7d5949198050962cb568dfa5e/zstandard-0.25.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:22a086cff1b6ceca18a8dd6096ec631e430e93a8e70a9ca5efa7561a00f826fa", size = 5822753, upload-time = "2025-09-14T22:16:49.316Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/be/94267dc6ee64f0f8ba2b2ae7c7a2df934a816baaa7291db9e1aa77394c3c/zstandard-0.25.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:72d35d7aa0bba323965da807a462b0966c91608ef3a48ba761678cb20ce5d8b7", size = 5366047, upload-time = "2025-09-14T22:16:51.328Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/a3/732893eab0a3a7aecff8b99052fecf9f605cf0fb5fb6d0290e36beee47a4/zstandard-0.25.0-cp311-cp311-win32.whl", hash = "sha256:f5aeea11ded7320a84dcdd62a3d95b5186834224a9e55b92ccae35d21a8b63d4", size = 436484, upload-time = "2025-09-14T22:16:55.005Z" },
+    { url = "https://files.pythonhosted.org/packages/43/a3/c6155f5c1cce691cb80dfd38627046e50af3ee9ddc5d0b45b9b063bfb8c9/zstandard-0.25.0-cp311-cp311-win_amd64.whl", hash = "sha256:daab68faadb847063d0c56f361a289c4f268706b598afbf9ad113cbe5c38b6b2", size = 506183, upload-time = "2025-09-14T22:16:52.753Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/3e/8945ab86a0820cc0e0cdbf38086a92868a9172020fdab8a03ac19662b0e5/zstandard-0.25.0-cp311-cp311-win_arm64.whl", hash = "sha256:22a06c5df3751bb7dc67406f5374734ccee8ed37fc5981bf1ad7041831fa1137", size = 462533, upload-time = "2025-09-14T22:16:53.878Z" },
+    { url = "https://files.pythonhosted.org/packages/82/fc/f26eb6ef91ae723a03e16eddb198abcfce2bc5a42e224d44cc8b6765e57e/zstandard-0.25.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7b3c3a3ab9daa3eed242d6ecceead93aebbb8f5f84318d82cee643e019c4b73b", size = 795738, upload-time = "2025-09-14T22:16:56.237Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1c/d920d64b22f8dd028a8b90e2d756e431a5d86194caa78e3819c7bf53b4b3/zstandard-0.25.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:913cbd31a400febff93b564a23e17c3ed2d56c064006f54efec210d586171c00", size = 640436, upload-time = "2025-09-14T22:16:57.774Z" },
+    { url = "https://files.pythonhosted.org/packages/53/6c/288c3f0bd9fcfe9ca41e2c2fbfd17b2097f6af57b62a81161941f09afa76/zstandard-0.25.0-cp312-cp312-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:011d388c76b11a0c165374ce660ce2c8efa8e5d87f34996aa80f9c0816698b64", size = 5343019, upload-time = "2025-09-14T22:16:59.302Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/15/efef5a2f204a64bdb5571e6161d49f7ef0fffdbca953a615efbec045f60f/zstandard-0.25.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6dffecc361d079bb48d7caef5d673c88c8988d3d33fb74ab95b7ee6da42652ea", size = 5063012, upload-time = "2025-09-14T22:17:01.156Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/37/a6ce629ffdb43959e92e87ebdaeebb5ac81c944b6a75c9c47e300f85abdf/zstandard-0.25.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:7149623bba7fdf7e7f24312953bcf73cae103db8cae49f8154dd1eadc8a29ecb", size = 5394148, upload-time = "2025-09-14T22:17:03.091Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/79/2bf870b3abeb5c070fe2d670a5a8d1057a8270f125ef7676d29ea900f496/zstandard-0.25.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:6a573a35693e03cf1d67799fd01b50ff578515a8aeadd4595d2a7fa9f3ec002a", size = 5451652, upload-time = "2025-09-14T22:17:04.979Z" },
+    { url = "https://files.pythonhosted.org/packages/53/60/7be26e610767316c028a2cbedb9a3beabdbe33e2182c373f71a1c0b88f36/zstandard-0.25.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5a56ba0db2d244117ed744dfa8f6f5b366e14148e00de44723413b2f3938a902", size = 5546993, upload-time = "2025-09-14T22:17:06.781Z" },
+    { url = "https://files.pythonhosted.org/packages/85/c7/3483ad9ff0662623f3648479b0380d2de5510abf00990468c286c6b04017/zstandard-0.25.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:10ef2a79ab8e2974e2075fb984e5b9806c64134810fac21576f0668e7ea19f8f", size = 5046806, upload-time = "2025-09-14T22:17:08.415Z" },
+    { url = "https://files.pythonhosted.org/packages/08/b3/206883dd25b8d1591a1caa44b54c2aad84badccf2f1de9e2d60a446f9a25/zstandard-0.25.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:aaf21ba8fb76d102b696781bddaa0954b782536446083ae3fdaa6f16b25a1c4b", size = 5576659, upload-time = "2025-09-14T22:17:10.164Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/31/76c0779101453e6c117b0ff22565865c54f48f8bd807df2b00c2c404b8e0/zstandard-0.25.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1869da9571d5e94a85a5e8d57e4e8807b175c9e4a6294e3b66fa4efb074d90f6", size = 4953933, upload-time = "2025-09-14T22:17:11.857Z" },
+    { url = "https://files.pythonhosted.org/packages/18/e1/97680c664a1bf9a247a280a053d98e251424af51f1b196c6d52f117c9720/zstandard-0.25.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:809c5bcb2c67cd0ed81e9229d227d4ca28f82d0f778fc5fea624a9def3963f91", size = 5268008, upload-time = "2025-09-14T22:17:13.627Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/73/316e4010de585ac798e154e88fd81bb16afc5c5cb1a72eeb16dd37e8024a/zstandard-0.25.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:f27662e4f7dbf9f9c12391cb37b4c4c3cb90ffbd3b1fb9284dadbbb8935fa708", size = 5433517, upload-time = "2025-09-14T22:17:16.103Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/60/dd0f8cfa8129c5a0ce3ea6b7f70be5b33d2618013a161e1ff26c2b39787c/zstandard-0.25.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:99c0c846e6e61718715a3c9437ccc625de26593fea60189567f0118dc9db7512", size = 5814292, upload-time = "2025-09-14T22:17:17.827Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/5f/75aafd4b9d11b5407b641b8e41a57864097663699f23e9ad4dbb91dc6bfe/zstandard-0.25.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:474d2596a2dbc241a556e965fb76002c1ce655445e4e3bf38e5477d413165ffa", size = 5360237, upload-time = "2025-09-14T22:17:19.954Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/8d/0309daffea4fcac7981021dbf21cdb2e3427a9e76bafbcdbdf5392ff99a4/zstandard-0.25.0-cp312-cp312-win32.whl", hash = "sha256:23ebc8f17a03133b4426bcc04aabd68f8236eb78c3760f12783385171b0fd8bd", size = 436922, upload-time = "2025-09-14T22:17:24.398Z" },
+    { url = "https://files.pythonhosted.org/packages/79/3b/fa54d9015f945330510cb5d0b0501e8253c127cca7ebe8ba46a965df18c5/zstandard-0.25.0-cp312-cp312-win_amd64.whl", hash = "sha256:ffef5a74088f1e09947aecf91011136665152e0b4b359c42be3373897fb39b01", size = 506276, upload-time = "2025-09-14T22:17:21.429Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/6b/8b51697e5319b1f9ac71087b0af9a40d8a6288ff8025c36486e0c12abcc4/zstandard-0.25.0-cp312-cp312-win_arm64.whl", hash = "sha256:181eb40e0b6a29b3cd2849f825e0fa34397f649170673d385f3598ae17cca2e9", size = 462679, upload-time = "2025-09-14T22:17:23.147Z" },
+    { url = "https://files.pythonhosted.org/packages/35/0b/8df9c4ad06af91d39e94fa96cc010a24ac4ef1378d3efab9223cc8593d40/zstandard-0.25.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ec996f12524f88e151c339688c3897194821d7f03081ab35d31d1e12ec975e94", size = 795735, upload-time = "2025-09-14T22:17:26.042Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/06/9ae96a3e5dcfd119377ba33d4c42a7d89da1efabd5cb3e366b156c45ff4d/zstandard-0.25.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a1a4ae2dec3993a32247995bdfe367fc3266da832d82f8438c8570f989753de1", size = 640440, upload-time = "2025-09-14T22:17:27.366Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/14/933d27204c2bd404229c69f445862454dcc101cd69ef8c6068f15aaec12c/zstandard-0.25.0-cp313-cp313-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:e96594a5537722fdfb79951672a2a63aec5ebfb823e7560586f7484819f2a08f", size = 5343070, upload-time = "2025-09-14T22:17:28.896Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/db/ddb11011826ed7db9d0e485d13df79b58586bfdec56e5c84a928a9a78c1c/zstandard-0.25.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bfc4e20784722098822e3eee42b8e576b379ed72cca4a7cb856ae733e62192ea", size = 5063001, upload-time = "2025-09-14T22:17:31.044Z" },
+    { url = "https://files.pythonhosted.org/packages/db/00/87466ea3f99599d02a5238498b87bf84a6348290c19571051839ca943777/zstandard-0.25.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:457ed498fc58cdc12fc48f7950e02740d4f7ae9493dd4ab2168a47c93c31298e", size = 5394120, upload-time = "2025-09-14T22:17:32.711Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/95/fc5531d9c618a679a20ff6c29e2b3ef1d1f4ad66c5e161ae6ff847d102a9/zstandard-0.25.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:fd7a5004eb1980d3cefe26b2685bcb0b17989901a70a1040d1ac86f1d898c551", size = 5451230, upload-time = "2025-09-14T22:17:34.41Z" },
+    { url = "https://files.pythonhosted.org/packages/63/4b/e3678b4e776db00f9f7b2fe58e547e8928ef32727d7a1ff01dea010f3f13/zstandard-0.25.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8e735494da3db08694d26480f1493ad2cf86e99bdd53e8e9771b2752a5c0246a", size = 5547173, upload-time = "2025-09-14T22:17:36.084Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/d5/ba05ed95c6b8ec30bd468dfeab20589f2cf709b5c940483e31d991f2ca58/zstandard-0.25.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3a39c94ad7866160a4a46d772e43311a743c316942037671beb264e395bdd611", size = 5046736, upload-time = "2025-09-14T22:17:37.891Z" },
+    { url = "https://files.pythonhosted.org/packages/50/d5/870aa06b3a76c73eced65c044b92286a3c4e00554005ff51962deef28e28/zstandard-0.25.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:172de1f06947577d3a3005416977cce6168f2261284c02080e7ad0185faeced3", size = 5576368, upload-time = "2025-09-14T22:17:40.206Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/35/398dc2ffc89d304d59bc12f0fdd931b4ce455bddf7038a0a67733a25f550/zstandard-0.25.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3c83b0188c852a47cd13ef3bf9209fb0a77fa5374958b8c53aaa699398c6bd7b", size = 4954022, upload-time = "2025-09-14T22:17:41.879Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/5c/36ba1e5507d56d2213202ec2b05e8541734af5f2ce378c5d1ceaf4d88dc4/zstandard-0.25.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:1673b7199bbe763365b81a4f3252b8e80f44c9e323fc42940dc8843bfeaf9851", size = 5267889, upload-time = "2025-09-14T22:17:43.577Z" },
+    { url = "https://files.pythonhosted.org/packages/70/e8/2ec6b6fb7358b2ec0113ae202647ca7c0e9d15b61c005ae5225ad0995df5/zstandard-0.25.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:0be7622c37c183406f3dbf0cba104118eb16a4ea7359eeb5752f0794882fc250", size = 5433952, upload-time = "2025-09-14T22:17:45.271Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/01/b5f4d4dbc59ef193e870495c6f1275f5b2928e01ff5a81fecb22a06e22fb/zstandard-0.25.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:5f5e4c2a23ca271c218ac025bd7d635597048b366d6f31f420aaeb715239fc98", size = 5814054, upload-time = "2025-09-14T22:17:47.08Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/e5/fbd822d5c6f427cf158316d012c5a12f233473c2f9c5fe5ab1ae5d21f3d8/zstandard-0.25.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4f187a0bb61b35119d1926aee039524d1f93aaf38a9916b8c4b78ac8514a0aaf", size = 5360113, upload-time = "2025-09-14T22:17:48.893Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e0/69a553d2047f9a2c7347caa225bb3a63b6d7704ad74610cb7823baa08ed7/zstandard-0.25.0-cp313-cp313-win32.whl", hash = "sha256:7030defa83eef3e51ff26f0b7bfb229f0204b66fe18e04359ce3474ac33cbc09", size = 436936, upload-time = "2025-09-14T22:17:52.658Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/82/b9c06c870f3bd8767c201f1edbdf9e8dc34be5b0fbc5682c4f80fe948475/zstandard-0.25.0-cp313-cp313-win_amd64.whl", hash = "sha256:1f830a0dac88719af0ae43b8b2d6aef487d437036468ef3c2ea59c51f9d55fd5", size = 506232, upload-time = "2025-09-14T22:17:50.402Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/57/60c3c01243bb81d381c9916e2a6d9e149ab8627c0c7d7abb2d73384b3c0c/zstandard-0.25.0-cp313-cp313-win_arm64.whl", hash = "sha256:85304a43f4d513f5464ceb938aa02c1e78c2943b29f44a750b48b25ac999a049", size = 462671, upload-time = "2025-09-14T22:17:51.533Z" },
+]