diff --git a/.github/workflows/generate-artifacts.yml b/.github/workflows/generate-artifacts.yml
index db294a005..3a484e441 100644
--- a/.github/workflows/generate-artifacts.yml
+++ b/.github/workflows/generate-artifacts.yml
@@ -66,6 +66,11 @@ jobs:
           filters: |
             native-changed:
               - 'thermion_dart/native/**'
+              # These drive the web (Emscripten) build too: the Makefile's wasm
+              # target and the scripts it calls decide what goes into the
+              # shipped thermion_dart.wasm.
+              - 'Makefile'
+              - 'scripts/download_reactphysics3d.sh'
             materials-changed:
               - 'materials/**'
               - 'examples/assets/*.mat'
@@ -197,6 +202,20 @@ jobs:
           restore-keys: |
             filament-web-
 
+      # ReactPhysics3D checkout + the published libreactphysics3d.a that gets
+      # linked into thermion_dart.wasm. Keyed on the download script so a tag
+      # bump in it re-fetches.
+      - name: Cache ReactPhysics3D web artifact
+        if: steps.changes.outputs.native-changed == 'true'
+        uses: actions/cache@v4
+        with:
+          path: thermion_dart/native/web/lib/external
+          key: rp3d-web-${{ hashFiles('scripts/download_reactphysics3d.sh') }}
+
+      # Builds the single thermion_dart WASM with ReactPhysics3D linked in via
+      # the EXTERNAL_PROJECTS hook. The engine library comes from the
+      # reactphysics3d_dart release that the download script pins; that
+      # repository's own build-artifacts workflow verifies its exports.
       - name: Compile web
         if: steps.changes.outputs.native-changed == 'true'
         run: make wasm
diff --git a/.tickets/the-tvf4.md b/.tickets/the-tvf4.md
new file mode 100644
index 000000000..06a90cda1
--- /dev/null
+++ b/.tickets/the-tvf4.md
@@ -0,0 +1,39 @@
+---
+id: the-tvf4
+status: in_progress
+deps: []
+links: []
+created: 2026-08-14T14:54:21Z
+type: feature
+priority: 2
+assignee: Nick Fisher
+tags: [dart, examples, physics]
+---
+# Create a Dart sample demonstrating basic physics
+
+Create a Dart sample (thermion example) showing basic physics. Use reactphysics3d_dart for the physics simulation and thermion_dart for rendering.
+
+## Context
+
+- Reference app: ~/Documents/mixworld (Flutter app, mounted read-only).
+  It already wires thermion_dart + reactphysics3d_dart together. Read it to
+  learn the integration pattern.
+- Physics package: reactphysics3d_dart (mounted read-only at
+  /Volumes/T7/projects/reactphysics3d_dart). It is a git repo on branch
+  master. It has an example/ dir with a heightfield example.
+- The sample lives in this repo (thermion), under examples/dart.
+  Follow the existing example structure (examples_lib / web_gallery).
+- Physics + rendering should run in the browser (WASM), like the other
+  dart examples.
+
+## Acceptance criteria
+
+1. New dart example under examples/dart that shows basic physics:
+   objects falling, bouncing, or colliding, rendered with thermion.
+2. Registered in the example registry so it appears in the web gallery
+   (see examples/dart/examples_lib/lib/src/registry.dart and
+   examples/dart/web_gallery).
+3. Works in the browser (WASM build), verified by building/running it.
+4. Code follows existing example style and passes `flutter analyze` /
+   `dart analyze` where applicable.
+
diff --git a/Makefile b/Makefile
index 0c05ca7db..5a9f8540d 100644
--- a/Makefile
+++ b/Makefile
@@ -1,3 +1,15 @@
+# ReactPhysics3D is compiled into the single thermion_dart WASM through the
+# EXTERNAL_PROJECTS hook in thermion_dart/native/web/CMakeLists.txt: thermion
+# itself never references the rp3d C API, so its objects are only kept alive by
+# the -Wl,--whole-archive group and its _rp3d_* functions are exported from the
+# same Module object as the _Thermion_* ones. That is what lets one
+# NativeLibrary.initBindings("thermion_dart") serve both packages on the web.
+# scripts/download_reactphysics3d.sh stages the reactphysics3d_dart checkout
+# and the published libreactphysics3d.a that the hook links in.
+# Set EXTERNAL_PROJECTS_CMAKE= (empty) to build a WASM without physics.
+RP3D_EXTERNAL_DIR := thermion_dart/native/web/lib/external
+EXTERNAL_PROJECTS_CMAKE ?= $(RP3D_EXTERNAL_DIR)/reactphysics3d_dart/native/web/reactphysics3d_dart.cmake
+
 wasm:
 	@if [ ! -f thermion_dart/native/web/lib/release/filament-v1.75.0-web-release.zip ]; then \
 		echo "Downloading filament-v1.75.0-web-release.zip..."; \
@@ -9,13 +21,17 @@ wasm:
 	cd thermion_dart/native/web/lib/release && \
 	rm -rf include lib && \
 	unzip -o filament-v1.75.0-web-release.zip
+ifneq ($(strip $(EXTERNAL_PROJECTS_CMAKE)),)
+	scripts/download_reactphysics3d.sh
+endif
 	cd thermion_dart/native/web && \
 	mkdir -p build && \
 	cd build && \
-	emcmake cmake .. && \
+	emcmake cmake $(if $(strip $(EXTERNAL_PROJECTS_CMAKE)),-DEXTERNAL_PROJECTS=$(abspath $(EXTERNAL_PROJECTS_CMAKE)),) .. && \
 	emmake make
 wasm-clean:
 	cd thermion_dart/native/web && rm -rf build
+	@echo "Note: $(RP3D_EXTERNAL_DIR) is kept (cached ReactPhysics3D checkout/artifact)."
 wasm-example-web: 
 	cd examples/dart/js_wasm
 	mkdir -p build
diff --git a/docs/research/web-physics-scope.md b/docs/research/web-physics-scope.md
new file mode 100644
index 000000000..e71d516c1
--- /dev/null
+++ b/docs/research/web-physics-scope.md
@@ -0,0 +1,294 @@
+# Scoping: unblocking the `physics_basics` example on the web path
+
+Date: 2026-08-19
+Branch: `asb/dart-physics-sample-clean` (PR #239, commit `470e44c9` — read via `refs/pull/239/head`)
+Status: research only — no code changed.
+
+## Background
+
+PR #239 adds `examples/dart/examples_lib/lib/src/physics_basics.dart` (boxes and
+spheres dropped onto a ground plane, simulated with `reactphysics3d_dart`,
+rendered with `thermion_dart`). The example is registered in `registry.dart`
+(headless CLI runner) but deliberately NOT in `galleryScenes` (web gallery),
+because the web path is blocked. The original ticket (`.tickets/the-tvf4.md` in
+the PR) required browser/WASM support as an acceptance criterion; it was
+descoped for the reasons below.
+
+Three blockers were claimed in the example's doc comment:
+
+1. `reactphysics3d_dart` pins `ffigen_js 0.0.5-pre`; `thermion_dart` needs
+   `^0.0.14-pre`; they only resolve via `dependency_overrides` in the example
+   pubspecs.
+2. Both packages' generated web bindings assign a single shared
+   `NativeLibrary.instance` inside `initBindings`, so loading a second WASM
+   module clobbers the first.
+3. The `reactphysics3d_dart` WASM runtime path is unverified.
+
+This document verifies each claim against the actual sources, then evaluates
+options and recommends a path. Reference checkouts used (cloned at their
+remote HEADs, plus the exact ref the PR pins):
+
+- `reactphysics3d_dart` @ `52eec72e06b322080d395415bc1dfaffd8c45d2f` — this IS
+  the current `master` HEAD; the PR pins it directly.
+- `ffigen_js` @ `06d47ad` (master, `0.0.14-pre`).
+
+## 1. Exact version state
+
+| Package | ffigen_js constraint | File |
+|---|---|---|
+| thermion_dart | `^0.0.14-pre` | `thermion_dart/pubspec.yaml:24` |
+| reactphysics3d_dart | `0.0.5-pre` (exact pin, no caret) | `pubspec.yaml` (dependencies) |
+
+- ffigen_js master is `0.0.14-pre`. There are **no git tags**; versions are
+  pubspec-only bumps. Version→commit map (from history): `0.0.5-pre` =
+  `901616e`, `0.0.13-pre` = `65324d3`, `0.0.14-pre` = `06d47ad`.
+- `reactphysics3d_dart` has no newer branch/tag relaxing the pin (branches:
+  `feat/trigger`, `fix/linux-arm64-artifact`; neither touches `ffigen_js`).
+- **The pin is a real dependency, not conservatism.** The checked-in generated
+  web bindings `lib/src/bindings/src/rp3d_js_interop.g.dart` (3153 lines,
+  header says "Generated by `package:jsgen`", the ffigen_js predecessor name)
+  were produced by the 0.0.5-era generator and are **runtime-incompatible**
+  with the 0.0.14 runtime, not merely version-locked:
+  - Struct field access in the 0.0.5-generated code uses byte-offset pointer
+    arithmetic, e.g. (from `RP3D_Vector3`):
+    ```dart
+    set x(double val) {
+      NativeLibrary.instance.setValue(this.address + 4, val.toJS, 'float');
+    }
+    ```
+    In 0.0.5, `Pointer.operator +` meant *byte offset*. In 0.0.14
+    (`ffigen_js/lib/src/types.dart:39`) it means *element count*:
+    `Pointer<T>(addr + numElements * sizeOf<T>())` — and
+    `sizeOf<RP3D_Vector3>()` **throws `UnsupportedError`** (`types.dart:26-35`
+    only knows primitives). thermion's own regenerated bindings use the new
+    pattern (`this.address.addr + 0`, constructing a new `Pointer` — e.g.
+    `thermion_dart_js_interop.g.dart:8788`), which is why thermion needs
+    `^0.0.14-pre`.
+  - Between 0.0.5 and 0.0.14 the runtime also changed `NativeType` subtypes
+    from extension types to abstract classes, added heap-tracking to
+    `Pointer.free()`, and (0.0.13, then restored in 0.0.14) fixed typed-data
+    `.address` handling. Generated code from 0.0.5 is not guaranteed to
+    compile, and definitely not to run, against 0.0.14.
+- Consequence for the PR's `dependency_overrides` (`ffigen_js: ^0.0.14-pre` in
+  `examples_lib`, `headless_runner`, and `web_gallery` pubspecs): it is "safe"
+  only because nothing *runs* rp3d code on web today. The web build still
+  *compiles* `rp3d_js_interop.g.dart` (it is exported from
+  `examples_lib.dart` → `physics_basics.dart` → `reactphysics3d_dart` →
+  conditional export), but any struct field access would throw at runtime.
+  The override hides the conflict; it does not resolve it.
+
+## 2. The `NativeLibrary.instance` singleton
+
+**It is one process-wide global. There is no per-module or per-binding
+keying, and no multi-module support in any ffigen_js version.**
+
+- `ffigen_js/lib/src/types.dart:319`: `late NativeLibrary _lib;` — a single
+  package-level global.
+- `extension type NativeLibrary` (`types.dart:455-522`) exposes
+  `static NativeLibrary get instance => _lib;`,
+  `static set instance(NativeLibrary lib) { _lib = lib; }`, and
+  `static void initBindings(String moduleName)` which does
+  `globalContext.getProperty(moduleName.toJS)` (a lookup of a global JS
+  variable by name, e.g. `window.thermion_dart`) and assigns `_lib`.
+- The generator template (`ffigen_js/lib/src/jsgen/code_generator/writer.dart`,
+  the block emitting `extension type GeneratedBindings(NativeLibrary _)`)
+  generates into every bindings file:
+  ```dart
+  static GeneratedBindings get instance => NativeLibrary.instance as GeneratedBindings;
+  static void initBindings(String moduleName) { ... NativeLibrary.instance = lib as NativeLibrary; }
+  ```
+  and every generated wrapper calls
+  `GeneratedBindings.instance._fn(...)` (`func.dart:303`). Both
+  `thermion_dart/lib/src/bindings/src/thermion_dart_js_interop.g.dart:11-20`
+  and `reactphysics3d_dart/lib/src/bindings/src/rp3d_js_interop.g.dart:11-20`
+  carry exactly this pattern.
+- Critically, **all** ffigen_js runtime helpers route through the same `_lib`:
+  `stackAlloc`/`malloc`/`free`, `makeUint8List`/`makeFloat32List`/…,
+  `String.toNativeUtf8()`, `getValue`/`setValue` (used by *every* generated
+  struct getter/setter in both packages), `addFunction`/`removeFunction`, and
+  `HEAPU8`/`HEAPF32` (used by `asTypedList`).
+- So with two separately loaded Emscripten modules, the second `initBindings`
+  call doesn't just "clobber a variable": the loser's subsequent
+  `setValue`/`stackAlloc` calls execute against the **wrong module's heap**
+  (addresses are plain ints), i.e. silent memory corruption, not a clean
+  error. Hand-written code reads the same singleton too
+  (`thermion_dart/lib/src/bindings/src/js_interop.dart:18`).
+
+How the JS side loads a module today (thermion gallery):
+`web_gallery/web/index.html:136-147` loads `thermion_dart.js`
+(Emscripten glue, `-sEXPORT_NAME=thermion_dart -sMODULARIZE`), awaits it onto
+`window.thermion_dart`, then boots the dart2wasm `main.wasm`;
+`web_gallery/web/main.dart:56` calls `NativeLibrary.initBindings("thermion_dart")`.
+Two modules *can* coexist as JS globals (different `EXPORT_NAME`s), and each
+exports the runtime methods ffigen_js needs (both builds pass the same
+`-sEXPORTED_RUNTIME_METHODS=getValue,setValue,UTF8ToString,stringToUTF8,writeArrayToMemory,lengthBytesUTF8,HEAPU8,stackSave,stackRestore`
+and `-sEXPORTED_FUNCTIONS=_malloc,stackAlloc,_free`); the blocker is purely
+the Dart-side singleton.
+
+## 3. True state of the `reactphysics3d_dart` web path (worse than "unverified")
+
+- Generated web bindings **exist** (`rp3d_js_interop.g.dart`, 0.0.5-era — a
+  usable starting point for regeneration).
+- **Nothing initializes them.** No call to `initBindings` anywhere in the
+  package; no loader JS; no `<script>` wiring; no async init hook.
+  `createReactPhysics3D()` (`lib/src/reactphysics3d.dart:155`) constructs
+  `FFIReactPhysics3D()` → `FFIPhysicsCommon()` whose constructor synchronously
+  calls `rp3d_physics_common_create()`. On web today that path would hit a
+  `LateInitializationError` on `_lib` (thermion's gallery sets the singleton,
+  but to the thermion module).
+- `lib/src/bindings/src/bindings.dart` selects per platform:
+  `export 'ffi.dart' if (dart.library.ffi) 'ffi.dart' if (dart.library.js_interop) 'rp3d_js_interop.g.dart';`
+  — which is why the native/headless path works under the version override.
+- **The standalone web build is broken/incomplete in the repo.**
+  `native/web/CMakeLists.txt` does
+  `add_executable(${MODULE_NAME} module_init.cpp)` but `module_init.cpp` is
+  not checked in; it also expects a prebuilt `libreactphysics3d.a` at
+  `native/web/lib/`, and `native/web/` contains only the two cmake files.
+  The comment in `native/web/reactphysics3d_dart.cmake` says it all: this
+  cmake is meant to be included by a *bigger* client build ("…linked into the
+  mixworld client build") — it appends
+  `reactphysics3d_dart_static`/`reactphysics3d` to `EXTERNAL_ALL_LIBRARIES`.
+- No prebuilt rp3d WASM is published anywhere (no download tool, no R2
+  artifact). `BUILDING.md` covers macOS/iOS/Android/Linux native only.
+
+## 4. Thermion's existing escape hatch: `EXTERNAL_PROJECTS`
+
+`thermion_dart/native/web/CMakeLists.txt` already has a mechanism for building
+third-party code **into the single thermion WASM**:
+
+- Lines 132-157: if `EXTERNAL_PROJECTS` is defined (a list of paths to
+  `.cmake` files), each is `include()`d; the included file appends targets to
+  `EXTERNAL_ALL_LIBRARIES`.
+- Lines ~340-371: `EXTERNAL_ALL_LIBRARIES` are linked into the one
+  `thermion_dart` executable with
+  `-Wl,--whole-archive` per library — explicitly "because nothing in Thermion
+  directly references these libraries", i.e. exactly the situation for rp3d,
+  whose `_rp3d_*` symbols are only referenced from Dart via JS interop.
+- Both C API layers use `extern "C" + EMSCRIPTEN_KEEPALIVE`
+  (thermion's `T*.cpp`; rp3d's `rp3d_c_api.cpp`), so rp3d's functions would
+  appear on the combined `Module` object exactly like `_Thermion_*` do.
+- This mechanism is what the downstream "mixworld" app uses today to combine
+  thermion + reactphysics3d in one WASM (per the rp3d cmake comment and the
+  PR ticket's reference app). It is **not** wired into thermion's own
+  `make wasm` / CI (`scripts/`, `.github/` have no `EXTERNAL_PROJECTS`
+  references).
+
+Why one combined WASM dissolves the singleton conflict: there is only one
+module, so thermion's `NativeLibrary.initBindings("thermion_dart")` (already
+called at `web_gallery/web/main.dart:56` before any scene setup) sets the one
+singleton to the combined module, which exports both `_Thermion_*` and
+`_rp3d_*`. rp3d's `GeneratedBindings.instance` reads the same singleton and
+resolves correctly. **No ffigen_js change and no second initBindings call are
+needed.** The second requirement is free: `FFIPhysicsCommon`'s synchronous
+constructor runs after the gallery's initBindings.
+
+## 5. Options
+
+### Option A — relax the pin + regenerate rp3d's web bindings
+**Repo: reactphysics3d_dart only.**
+
+- Bump `ffigen_js` to `^0.0.14-pre`, run
+  `dart run ffigen_js --config ffigen/web.yaml` (config already exists and
+  mirrors thermion's `ffigen/web.yaml`), fix any fallout in the hand-written
+  `implementation/ffi_*.dart` files (they use wrapper functions and the
+  `StructAllocator`/typedef shims from `bindings.dart`, so fallout should be
+  small), keep native tests green.
+- Does **not** by itself deliver web: still no module loading, and if two
+  modules were loaded the singleton conflict would remain.
+- **Effort: 0.5–1 day. Risk: low. This is a prerequisite for every web
+  path**, and it also removes the need for the PR's three
+  `dependency_overrides` entries.
+
+### Option B — two separate WASM modules on one page
+**Repos: ffigen_js + reactphysics3d_dart + thermion_dart.**
+
+- Requires a real ffigen_js redesign: per-binding library instances instead of
+  one `_lib`. The hard part is not the generated wrappers (each
+  `GeneratedBindings` could hold its own static) but the **shared helpers** in
+  `types.dart` (`stackAlloc`, `toNativeUtf8`, `makeFloat32List`,
+  `getValue/setValue`, `HEAPU8`-backed `asTypedList`) that both packages'
+  generated code calls — they must dispatch on the *caller's* module, which
+  means passing the library through every generated call or a zone-based
+  "current library" (fragile). Then: regenerate both packages' bindings,
+  update hand-written uses (`thermion_dart/.../js_interop.dart`),
+  build+publish a second Emscripten artifact for rp3d (its standalone web
+  build needs `module_init.cpp` restored), extend the gallery `index.html` to
+  load and await both modules, and add a second `initBindings` call.
+- Also doubles committed memory (both builds use `-sINITIAL_MEMORY=512mb
+  -sALLOW_MEMORY_GROWTH=0`) and adds a second pthread pool.
+- **Effort: 1.5–3 weeks** (ffigen_js API redesign + three coordinated
+  releases + new artifact pipeline). **Risk: high.** Worst
+  payoff-for-effort; only worth it if two *independent* WASM modules ever
+  need to coexist generally.
+
+### Option C — one combined WASM via `EXTERNAL_PROJECTS` (recommended)
+**Repos: reactphysics3d_dart (Option A) + thermion (build wiring) + tiny examples change.**
+
+1. reactphysics3d_dart: Option A (pin bump + regenerate).
+2. thermion: wire `EXTERNAL_PROJECTS` into the web WASM build —
+   `make wasm` / web CI clones reactphysics3d_dart at a pinned ref (or fetches
+   a published emscripten build of `libreactphysics3d.a`; rp3d vendors the
+   engine source at `native/include/reactphysics3d/`, so
+   `emcmake`-building it in CI is straightforward), passes
+   `-DEXTERNAL_PROJECTS=<...>/native/web/reactphysics3d_dart.cmake`, uploads
+   the new zip, bumps `web.version`. Whole-archive linking keeps `_rp3d_*`
+   alive; thermion's Dart code needs **zero changes**.
+3. thermion examples: delete the `dependency_overrides` blocks from the three
+   pubspecs, add a `'physics': setupPhysicsBasics` entry to `galleryScenes`
+   (`examples/dart/examples_lib/lib/src/registry.dart`), verify in a browser
+   (the gallery's headless Chrome check can cover it).
+- **Effort: ~2.5–4 days total** (A: 0.5–1d; build/CI wiring: 1–2d; gallery +
+  cleanup: 0.5d). **Risk: medium-low.** Precedent: the mechanism exists and is
+  exercised downstream by mixworld today.
+- Tradeoff: the *shipped* `thermion_dart.wasm` now carries rp3d —
+  likely +1–2 MB and a version coupling (thermion `web.version` bumps must
+  track the rp3d ref). Given the project already ships a ~512 MB-initial-memory
+  Filament build and previously considered building libassimp into the same
+  artifact, this coupling is consistent with how the project treats the web
+  artifact.
+
+### Option D — keep physics out of the gallery; dedicated web page
+- A dedicated example page with its own build either (a) still loads two
+  modules → blocked exactly like Option B, or (b) builds a one-off combined
+  WASM → all of Option C's build plumbing *minus* the shipped-artifact update,
+  but with a second artifact pipeline to maintain and no gallery visibility.
+  Only sensible if the owner refuses to ship rp3d inside the main artifact.
+
+### Option E — other ideas considered and rejected
+- **Compile both into one WASM at the Dart level** — not applicable; the
+  split is at the C/Emscripten level, not Dart.
+- **Per-package renamed copies of the ffigen_js runtime** (two package names,
+  two `_lib`s) — works in principle, needs no ffigen_js upstream change, but
+  requires maintaining a fork/rename and regenerating rp3d against it; more
+  moving parts than Option C with no benefit.
+- **Status quo** (PR as-is: native/headless only) — zero cost, web stays
+  blocked, `dependency_overrides` keep papering over the conflict.
+
+## 6. Recommendation
+
+**Option C, in this order:**
+
+1. **reactphysics3d_dart** — relax `ffigen_js` to `^0.0.14-pre`, regenerate
+   `rp3d_js_interop.g.dart`, add a CI step that analyzes/builds the web
+   bindings (nothing currently verifies them). *(0.5–1 day)*
+2. **thermion** — wire `EXTERNAL_PROJECTS` into the web WASM build + CI,
+   publish a new `thermion_dart-<version>-web.zip`, bump `web.version`.
+   *(1–2 days)*
+3. **thermion examples** — drop the three `dependency_overrides` blocks, add
+   the scene to `galleryScenes`, verify. *(0.5 day)*
+4. **ffigen_js (optional hardening, not required)** — make
+   `NativeLibrary.initBindings` warn when re-pointing at a different module,
+   and document the one-module-per-page limitation. *(0.5 day)*
+
+**What must change where:**
+
+| Repo | Required change |
+|---|---|
+| reactphysics3d_dart | pubspec pin bump; regenerate web bindings with ffigen_js 0.0.14; (ideally) CI coverage for the web bindings |
+| thermion | web WASM build/CI: link rp3d via `EXTERNAL_PROJECTS`; new artifact + `web.version` bump |
+| thermion examples | remove `dependency_overrides`; add `physics` to `galleryScenes` |
+| ffigen_js | nothing required (optional: initBindings guard + docs) |
+
+**Upstream ffigen_js work: none under Option C.** General multi-module support
+(Option B) is a separate, larger project that should only be started if two
+independent WASM modules ever need to coexist on one page.
diff --git a/examples/README.md b/examples/README.md
index 56aa35fc9..ed1a8e294 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -2,4 +2,20 @@
 
 This repository contains example Dart and Flutter projects for the Thermion rendering toolkit.
 
+## Dart examples
+
+Shared scene setups live in `dart/examples_lib`; each is registered in
+`dart/examples_lib/lib/src/registry.dart`. Render any of them offscreen with
+the headless CLI runner:
+
+```sh
+cd dart/headless_runner
+dart run bin/run_example.dart <name> [width] [height]   # PNG lands in output/
+```
+
+`physics_basics` (ReactPhysics3D simulation rendered with Thermion) also runs
+in the WASM web gallery as the `physics` scene (`?example=physics`):
+ReactPhysics3D is compiled into the same `thermion_dart.wasm` as Thermion
+itself -- see `scripts/download_reactphysics3d.sh` and
+`docs/research/web-physics-scope.md`.
 
diff --git a/examples/dart/examples_lib/lib/examples_lib.dart b/examples/dart/examples_lib/lib/examples_lib.dart
index 3f5b09855..e6357e456 100644
--- a/examples/dart/examples_lib/lib/examples_lib.dart
+++ b/examples/dart/examples_lib/lib/examples_lib.dart
@@ -22,6 +22,7 @@ export 'src/lighting_setup.dart';
 export 'src/load_gltf.dart';
 export 'src/materials_pbr.dart';
 export 'src/morph_targets.dart';
+export 'src/physics_basics.dart';
 export 'src/picking.dart';
 export 'src/post_processing.dart';
 export 'src/render_targets.dart';
diff --git a/examples/dart/examples_lib/lib/src/physics_basics.dart b/examples/dart/examples_lib/lib/src/physics_basics.dart
new file mode 100644
index 000000000..359c6621e
--- /dev/null
+++ b/examples/dart/examples_lib/lib/src/physics_basics.dart
@@ -0,0 +1,178 @@
+import 'package:reactphysics3d_dart/reactphysics3d_dart.dart';
+import 'package:thermion_dart/thermion_dart.dart';
+
+/// Basic physics: boxes and spheres dropped onto a ground plane.
+///
+/// The simulation runs with reactphysics3d_dart, the rendering with
+/// thermion_dart. The world is stepped a fixed number of times with a fixed
+/// time step (no wall-clock dependency), then each body's transform is copied
+/// to its Thermion entity. That way the headless CLI runner can capture a
+/// single frame of the settled pile.
+///
+/// NOTE (web): ReactPhysics3D is compiled into the same thermion_dart WASM as
+/// thermion itself (linked through the EXTERNAL_PROJECTS hook in
+/// native/web/CMakeLists.txt), so the module that NativeLibrary.initBindings
+/// points at exports the _rp3d_* C API alongside the _Thermion_* one. This
+/// scene is registered as 'physics' in [galleryScenes]; see
+/// docs/research/web-physics-scope.md for the design.
+Future<void> setupPhysicsBasics(
+  ThermionViewer viewer, {
+  required String assetsDir,
+}) async {
+  final camera = await viewer.getActiveCamera();
+  await camera.setLensProjection(near: 0.1, far: 100.0, aspect: 1.0, focalLength: 28.0);
+  await camera.lookAt(Vector3(0, 7, 16), focus: Vector3(0, 1.5, 0));
+
+  await viewer.addDirectLight(
+    DirectLight.sun(intensity: 50000, direction: Vector3(0, -1, -1)),
+  );
+  await viewer.loadSkybox("$assetsDir/default_env_skybox.ktx");
+  await viewer.loadIbl("$assetsDir/default_env_ibl.ktx");
+
+  // Simple coloured PBR materials so the bodies stand out against the ground.
+  // Each instance is destroyed on viewer dispose: leaving ubershader material
+  // instances alive blocks FilamentApp.destroy() (the render thread never
+  // finishes tearing the engine down). Disposal runs after the viewer has
+  // destroyed its geometry assets, so the instances are unreferenced by then.
+  Future<MaterialInstance> coloredMaterial(double r, double g, double b) async {
+    final material = await FilamentApp.instance!.createUbershaderMaterialInstance();
+    await material.setParameterInt('baseColorIndex', -1);
+    await material.setParameterFloat4('baseColorFactor', r, g, b, 1.0);
+    viewer.onDispose(material.destroy);
+    return material;
+  }
+
+  // Physics world.
+  final physics = createReactPhysics3D();
+  final world = physics.createWorld();
+  world.setGravity(Vector3(0, -9.81, 0));
+
+  // Static ground: a box collider whose top surface sits at y=0.
+  final groundShape = physics.createBoxShape(Vector3(20, 0.5, 20));
+  final groundBody = physics.createRigidBody(
+    world,
+    transform: (
+      position: Vector3(0, -0.5, 0),
+      orientation: Quaternion.identity(),
+    ),
+    type: BodyType.STATIC,
+    mass: 0,
+  );
+  final groundCollider = groundBody.addCollider(groundShape);
+  groundCollider.material.setFrictionCoefficient(0.8);
+  groundCollider.material.setBounciness(0.0);
+
+  // Rendered ground: a flat cube matching the collider (cube spans [-1,1]).
+  final groundMesh = await viewer.createGeometry(
+    GeometryUtils.cube(uvs: false),
+    materialInstances: [await coloredMaterial(0.35, 0.35, 0.35)],
+  );
+  await groundMesh.setTransform(
+    Matrix4.compose(Vector3(0, -0.5, 0), Quaternion.identity(), Vector3(20, 0.5, 20)),
+  );
+
+  // Low walls around the drop zone so the rolling spheres stay in frame.
+  // Each wall is a static box collider plus a matching thin cube mesh.
+  final wallShape = physics.createBoxShape(Vector3(8, 1, 0.5));
+  const wallSpecs = [
+    (0.0, -8.0, 0.0),
+    (0.0, 8.0, 0.0),
+    (-8.0, 0.0, 1.5707963267948966),
+    (8.0, 0.0, 1.5707963267948966),
+  ];
+  for (final (x, z, yaw) in wallSpecs) {
+    final wallBody = physics.createRigidBody(
+      world,
+      transform: (
+        position: Vector3(x, 1.0, z),
+        orientation: Quaternion.euler(yaw, 0, 0),
+      ),
+      type: BodyType.STATIC,
+      mass: 0,
+    );
+    final wallCollider = wallBody.addCollider(wallShape);
+    wallCollider.material.setFrictionCoefficient(0.8);
+    wallCollider.material.setBounciness(0.0);
+    final wallMesh = await viewer.createGeometry(
+      GeometryUtils.cube(uvs: false),
+      materialInstances: [await coloredMaterial(0.55, 0.55, 0.6)],
+    );
+    await wallMesh.setTransform(
+      Matrix4.compose(Vector3(x, 1.0, z), Quaternion.euler(yaw, 0, 0), Vector3(8, 1, 0.5)),
+    );
+  }
+
+  final bodies = <(ThermionAsset, RigidBody)>[];
+
+  // Falling boxes. GeometryUtils.cube() spans [-1,1], so the physics box has
+  // half-extent 1 and the render scale stays 1.
+  final boxShape = physics.createBoxShape(Vector3.all(1));
+  const boxSpecs = [
+    (-2.5, 6.0, 0.0),
+    (0.0, 9.0, 1.5),
+    (2.5, 6.0, -1.0),
+    (0.5, 13.0, 0.5),
+  ];
+  for (final (x, y, z) in boxSpecs) {
+    final body = physics.createRigidBody(
+      world,
+      transform: (
+        position: Vector3(x, y, z),
+        orientation: Quaternion.identity(),
+      ),
+    );
+    final collider = body.addCollider(boxShape);
+    collider.material.setBounciness(0.15);
+    collider.material.setFrictionCoefficient(0.9);
+    final mesh = await viewer.createGeometry(
+      GeometryUtils.cube(uvs: false),
+      materialInstances: [await coloredMaterial(0.9, 0.4, 0.1)],
+    );
+    bodies.add((mesh, body));
+  }
+
+  // Falling spheres. GeometryUtils.sphere() has radius 1.
+  final sphereShape = physics.createSphereShape(1.0);
+  const sphereSpecs = [
+    (-1.5, 11.0, 1.0),
+    (1.8, 8.0, 1.2),
+    (0.0, 15.0, -0.5),
+  ];
+  for (final (x, y, z) in sphereSpecs) {
+    final body = physics.createRigidBody(
+      world,
+      transform: (
+        position: Vector3(x, y, z),
+        orientation: Quaternion.identity(),
+      ),
+    );
+    final collider = body.addCollider(sphereShape);
+    collider.material.setBounciness(0.3);
+    collider.material.setFrictionCoefficient(0.7);
+    final mesh = await viewer.createGeometry(
+      GeometryUtils.sphere(uvs: false),
+      materialInstances: [await coloredMaterial(0.2, 0.45, 0.9)],
+    );
+    bodies.add((mesh, body));
+  }
+
+  // Step the simulation long enough for everything to settle (5 seconds at
+  // 60 Hz). Fixed step count keeps the captured frame deterministic.
+  const timeStep = 1 / 60;
+  const steps = 300;
+  for (var i = 0; i < steps; i++) {
+    world.update(timeStep);
+  }
+
+  // Copy the final physics transforms to the render entities.
+  for (final (mesh, body) in bodies) {
+    final transform = body.transform;
+    await mesh.setTransform(
+      Matrix4.compose(
+        transform.position,
+        transform.orientation,
+        Vector3.all(1),
+      ),
+    );
+  }
+}
diff --git a/examples/dart/examples_lib/lib/src/registry.dart b/examples/dart/examples_lib/lib/src/registry.dart
index ba4c4f0c3..2d2afdcad 100644
--- a/examples/dart/examples_lib/lib/src/registry.dart
+++ b/examples/dart/examples_lib/lib/src/registry.dart
@@ -11,6 +11,7 @@ import 'instancing.dart';
 import 'materials_and_lighting.dart';
 import 'materials_pbr.dart';
 import 'morph_targets.dart';
+import 'physics_basics.dart';
 import 'picking.dart';
 import 'post_processing.dart';
 import 'render_targets.dart';
@@ -53,6 +54,9 @@ final Map<String, ExampleSetup> registry = {
   'load_via_assimp': setupLoadViaAssimp,
   'materials_pbr': setupMaterialsPbr,
   'morph_targets': setupMorphTargets,
+  // Registered for the headless CLI runner and the web gallery (as the
+  // 'physics' gallery scene).
+  'physics_basics': setupPhysicsBasics,
   'picking': setupPicking,
   'post_processing': setupPostProcessing,
   'render_targets': setupRenderTargets,
@@ -72,4 +76,9 @@ final Map<String, ExampleSetup> galleryScenes = {
   'materials_and_lighting': setupMaterialsAndLighting,
   'animation': setupAnimation,
   'effects': setupEffects,
+  // ReactPhysics3D is compiled into the same thermion_dart WASM (linked via
+  // the EXTERNAL_PROJECTS hook in native/web/CMakeLists.txt), so the module
+  // that NativeLibrary.initBindings points at exports the _rp3d_* C API
+  // alongside the _Thermion_* one. See docs/research/web-physics-scope.md.
+  'physics': setupPhysicsBasics,
 };
diff --git a/examples/dart/examples_lib/pubspec.yaml b/examples/dart/examples_lib/pubspec.yaml
index d893b731b..2b6f51bf6 100644
--- a/examples/dart/examples_lib/pubspec.yaml
+++ b/examples/dart/examples_lib/pubspec.yaml
@@ -13,3 +13,19 @@ dependencies:
     git:
       url: https://github.com/nmfisher/assimp_dart.git
   vector_math: ^2.1.4
+  reactphysics3d_dart:
+    git:
+      url: https://github.com/nmfisher/reactphysics3d_dart.git
+      ref: 52eec72e06b322080d395415bc1dfaffd8c45d2f
+
+# TEMPORARY: reactphysics3d_dart (at the ref above) still pins ffigen_js
+# 0.0.5-pre, which conflicts with thermion_dart's ffigen_js ^0.0.14-pre, so
+# version solving fails without this override. The web path no longer depends
+# on it -- ReactPhysics3D is linked into the single thermion_dart WASM (see
+# scripts/download_reactphysics3d.sh) -- but the *generated* web bindings in
+# reactphysics3d_dart are still 0.0.5-era, so struct field access would throw
+# at runtime until that package regenerates them under 0.0.14. When it does:
+# bump the git ref above and delete this override (and the mirrors in
+# headless_runner/ and web_gallery/).
+dependency_overrides:
+  ffigen_js: ^0.0.14-pre
diff --git a/examples/dart/headless_runner/.gitignore b/examples/dart/headless_runner/.gitignore
new file mode 100644
index 000000000..ea1472ec1
--- /dev/null
+++ b/examples/dart/headless_runner/.gitignore
@@ -0,0 +1 @@
+output/
diff --git a/examples/dart/headless_runner/pubspec.yaml b/examples/dart/headless_runner/pubspec.yaml
index 8e68df048..f9df262c7 100644
--- a/examples/dart/headless_runner/pubspec.yaml
+++ b/examples/dart/headless_runner/pubspec.yaml
@@ -11,3 +11,12 @@ dependencies:
     path: ../../../thermion_dart
   thermion_examples_lib:
     path: ../examples_lib
+
+# Mirrors the override in examples_lib (pub only honours overrides from the
+# root package): reactphysics3d_dart pins ffigen_js 0.0.5-pre, conflicting
+# with thermion_dart's ffigen_js ^0.0.14-pre. This runner is native-only, so
+# the web bindings the override affects are never exercised here. Delete
+# together with the examples_lib override once reactphysics3d_dart relaxes
+# its pin.
+dependency_overrides:
+  ffigen_js: ^0.0.14-pre
diff --git a/examples/dart/web_gallery/pubspec.yaml b/examples/dart/web_gallery/pubspec.yaml
index 24ea042b4..253212eb8 100644
--- a/examples/dart/web_gallery/pubspec.yaml
+++ b/examples/dart/web_gallery/pubspec.yaml
@@ -14,6 +14,16 @@ dependencies:
   logging: ^1.3.0
   web: ^1.0.0
 
+# Mirrors the override in examples_lib (pub only honours overrides from the
+# root package): reactphysics3d_dart (a transitive dep via examples_lib) pins
+# ffigen_js 0.0.5-pre, conflicting with thermion_dart's ^0.0.14-pre. Without
+# this override `dart pub get` fails here. The physics scene this gallery
+# serves needs reactphysics3d_dart's web bindings regenerated under 0.0.14 to
+# work at runtime; delete this override together with the others once that
+# lands and the git ref in examples_lib is bumped.
+dependency_overrides:
+  ffigen_js: ^0.0.14-pre
+
 # This package only ever builds for the web (compiled to WASM), so it never
 # needs a host native build. Setting skip_native_build lets us run Thermion's
 # pure-Dart tooling here — notably `dart run thermion_dart:download_web`, which
diff --git a/scripts/download_reactphysics3d.sh b/scripts/download_reactphysics3d.sh
new file mode 100755
index 000000000..763d727f2
--- /dev/null
+++ b/scripts/download_reactphysics3d.sh
@@ -0,0 +1,106 @@
+#!/bin/bash
+
+# Stages ReactPhysics3D for the thermion web (Emscripten) build.
+#
+# thermion's web CMakeLists links third-party code into the single
+# thermion_dart WASM through the EXTERNAL_PROJECTS hook: nothing in thermion
+# references the rp3d C API, so its objects are only pulled in by the
+# -Wl,--whole-archive group and its _rp3d_* functions end up on the same Module
+# object as the _Thermion_* ones.
+#
+# ReactPhysics3D itself is NOT built here. reactphysics3d_dart publishes
+# prebuilt libraries from its own "Build artifacts" workflow (see BUILDING.md,
+# "Release artifacts", in that repository); this script downloads the
+# web-emscripten zip and stages what the hook needs:
+#
+#   1. a reactphysics3d_dart checkout at the pinned tag, providing
+#      native/web/reactphysics3d_dart.cmake (the file EXTERNAL_PROJECTS points
+#      at), the C API wrapper it compiles (native/src/rp3d_c_api.cpp) and the
+#      headers under native/include/, and
+#   2. libreactphysics3d.a (engine, wasm32) from the release zip, dropped next
+#      to that cmake file, which imports it as a prebuilt library.
+#
+# The zip also ships libreactphysics3d_dart.a -- the same wrapper prebuilt --
+# which is not extracted: the cmake hook compiles the wrapper from source so
+# the C API always matches the vendored headers of the checked-out tag.
+#
+# Everything is cached under thermion_dart/native/web/lib/external/, which
+# survives `make wasm-clean` (it only removes native/web/build) and is
+# gitignored/pubignored like the Filament web libraries.
+
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+# The reactphysics3d_dart release to build against. Both the downloaded zip
+# and the staged checkout come from this tag, so the C API the Dart bindings
+# call and the engine library that implements it cannot drift apart.
+#
+# reactphysics3d_dart publishes on `v*` tag pushes only (its build-artifacts
+# workflow stops short of publishing on pull requests); cutting a release is
+# `git tag v<x.y.z> && git push origin v<x.y.z>` in that repository.
+RP3D_DART_REPO="${RP3D_DART_REPO:-https://github.com/nmfisher/reactphysics3d_dart.git}"
+RP3D_DART_TAG="${RP3D_DART_TAG:-v0.1.0}"
+RP3D_DART_VERSION="${RP3D_DART_VERSION:-${RP3D_DART_TAG#v}}"
+RP3D_DART_ZIP_URL="${RP3D_DART_ZIP_URL:-${RP3D_DART_REPO%.git}/releases/download/${RP3D_DART_TAG}/reactphysics3d_dart-${RP3D_DART_VERSION}-web-emscripten.zip}"
+
+CACHE_DIR="${RP3D_WEB_CACHE_DIR:-$REPO_ROOT/thermion_dart/native/web/lib/external}"
+DART_DIR="$CACHE_DIR/reactphysics3d_dart"
+STAMP_FILE="$CACHE_DIR/.stamp"
+ENGINE_LIB="$DART_DIR/native/web/libreactphysics3d.a"
+
+CURRENT_STAMP="tag=$RP3D_DART_TAG url=$RP3D_DART_ZIP_URL"
+
+if [ -f "$STAMP_FILE" ] && [ "$(cat "$STAMP_FILE")" = "$CURRENT_STAMP" ] && [ -s "$ENGINE_LIB" ]; then
+  echo "ReactPhysics3D $RP3D_DART_TAG already staged at $CACHE_DIR"
+else
+  mkdir -p "$CACHE_DIR"
+
+  if [ ! -d "$DART_DIR/.git" ]; then
+    echo "Cloning $RP3D_DART_REPO into $DART_DIR ..."
+    git init -q "$DART_DIR"
+    git -C "$DART_DIR" remote add origin "$RP3D_DART_REPO"
+  fi
+
+  echo "Checking out reactphysics3d_dart $RP3D_DART_TAG ..."
+  if ! git -C "$DART_DIR" fetch -q --depth 1 origin "refs/tags/$RP3D_DART_TAG"; then
+    echo ""
+    echo "Error: tag $RP3D_DART_TAG not found in $RP3D_DART_REPO."
+    echo "reactphysics3d_dart publishes its libraries from 'v*' tag pushes"
+    echo "only (its build-artifacts workflow stops short of publishing on"
+    echo "pull requests). Cut the release there first:"
+    echo "  git tag $RP3D_DART_TAG && git push origin $RP3D_DART_TAG"
+    exit 1
+  fi
+  git -C "$DART_DIR" checkout -q --detach FETCH_HEAD
+
+  ZIP_FILE="$CACHE_DIR/reactphysics3d_dart-$RP3D_DART_VERSION-web-emscripten.zip"
+  echo "Downloading $RP3D_DART_ZIP_URL ..."
+  if ! curl -fSL --retry 3 -o "$ZIP_FILE" "$RP3D_DART_ZIP_URL"; then
+    echo ""
+    echo "Error: could not download $RP3D_DART_ZIP_URL."
+    echo "The release asset is created by the same 'v*' tag push that"
+    echo "provides the checkout above -- see BUILDING.md, \"Release"
+    echo "artifacts\", in the reactphysics3d_dart repository."
+    exit 1
+  fi
+
+  # The zip is flat: libreactphysics3d.a, libreactphysics3d_dart.a, README.txt.
+  # Extract only the engine library -- see the note at the top of this script.
+  unzip -oq "$ZIP_FILE" libreactphysics3d.a -d "$DART_DIR/native/web/"
+
+  if [ ! -s "$ENGINE_LIB" ]; then
+    echo "Error: $ENGINE_LIB was not extracted from $ZIP_FILE"
+    exit 1
+  fi
+
+  echo "$CURRENT_STAMP" > "$STAMP_FILE"
+fi
+
+RP3D_CMAKE="$DART_DIR/native/web/reactphysics3d_dart.cmake"
+if [ ! -f "$RP3D_CMAKE" ]; then
+  echo "Error: $RP3D_CMAKE not found"
+  exit 1
+fi
+
+echo "ReactPhysics3D staged: $RP3D_CMAKE"
diff --git a/thermion_dart/analysis_options.yaml b/thermion_dart/analysis_options.yaml
index ecd299f3e..d26e7a1a8 100644
--- a/thermion_dart/analysis_options.yaml
+++ b/thermion_dart/analysis_options.yaml
@@ -11,6 +11,11 @@ analyzer:
     # Linting generated code is noise (e.g. dozens of unnecessary_cast).
     - lib/src/bindings/src/thermion_dart_ffi.g.dart
     - lib/src/bindings/src/thermion_dart_js_interop.g.dart
+    # Third-party sources staged by scripts/download_reactphysics3d.sh for the
+    # Emscripten build. They are a gitignored build input (see .pubignore), not
+    # part of this package, and do not resolve as one -- their package: URIs
+    # have no package_config.
+    - native/web/lib/external/**
 
 formatter:
   page_width: 120