fix(handtracking): absorb React StrictMode double-mount

In dev, <StrictMode> intentionally mounts → unmounts → remounts each
effect to surface non-idempotent code. The hand tracking hooks were
calling getUserMedia and creating MediaPipe / WebSocket runtimes on
every mount, which in practice ran the full start/stop/start cycle
inside a few milliseconds and pushed WebGL over its limit on top
of the loaded scene → context lost.

Add HAND_TRACKING_RUNTIME_START_DELAY_MS (80ms) and delay the actual
start() call behind a setTimeout in both useBrowserHandTracking and
useRemoteHandTracking. The cleanup clears the timer, so a fast
mount/unmount never reaches start(). 80ms is invisible to the user
(<5 frames at 60fps) and also absorbs rapid `nearby` toggles at
trigger borders.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

docs/technical/map-lod.md

@@ -25,7 +25,7 @@ Current behavior:
 | -------- | ------------------: | --- | ------------------------------------- |
 | `low`    |                 10m | On  | Always use `*-LOD` models             |
 | `medium` |                 20m | On  | Always use `*-LOD` models             |
-| `high`   | Current default 50m | Off | Regular model up to 10m, then `*-LOD` |
+| `high`   |                 35m | Off | Regular model up to 10m, then `*-LOD` |
 | `ultra`  |                 50m | Off | Regular model up to 20m, then `*-LOD` |
 
 The unload distance stays slightly larger than the load distance to avoid rapid mount/unmount flickering when the player stands near a boundary.

docs/technical/map-performance.md

@@ -158,9 +158,11 @@ Current runtime values:
 
 ```txt
 chunkSize: 35
-loadRadius: 45
+low load/unload radius: 10m / 18m
-unloadRadius: 45
+medium load/unload radius: 20m / 30m
-updateInterval: 350ms
+high load/unload radius: 35m / 45m
+ultra load/unload radius: 50m / 65m
+updateInterval: 250ms
 fog near: 30
 fog far: 45
 ```

docs/technical/scene-runtime.md

@@ -74,22 +74,32 @@ It tracks:
 - `gameMapLoaded`: map data and visible map nodes settled
 - `gameStageLoaded`: Rapier gameplay stage mounted
 - `showGameStage`: true when the map is ready enough to mount gameplay content
-- `shadowsReady`: renderer, shadow lights, and scene matrices have been forced once after the scene is mounted
+- `gameplayReady`: true when map, stage, and octree are all ready
-- `gameplayReady`: true when map, stage, octree, and the shadow warmup are all ready
 
-The base game-scene readiness condition before the shadow warmup is:
+The game-scene readiness condition is:
 
 ```ts
 showGameStage && gameStageLoaded && octree !== null;
 ```
 
-After that condition is met, `SceneShadowWarmup` runs one final loading step:
+Shadows are configured once when `Lighting` mounts (renderer `shadowMap.enabled`, sun
+`shadow.autoUpdate = true`, bias and frustum from `SHADOW_CONFIG` in
+`src/data/world/lightingConfig.ts`). The shadow map then refreshes every frame and
+follows the player camera through the sun's `target`. The earlier `SceneShadowWarmup`
+step has been removed — the visible loading overlay no longer waits for a forced
+shadow refresh because `autoUpdate` covers steady-state rendering.
 
-```txt
+### Avoiding global scene remounts
-Activation des ombres -> Ombres prêtes -> Gameplay prêt
-```
 
-This keeps the loading overlay visible until the renderer shadow map, shadow-casting light, and mounted scene graph have all been explicitly refreshed.
+Heavy stage components (`GameStageContent`, `Player`, dialogues) load assets via
+`useGLTF`/`useTexture` without preload (e.g. `EbikeSpeedometer` calls `useTexture`
+when the bike mounts). To prevent any late suspension from bubbling up to the
+root `<Suspense>` boundary in `src/pages/page.tsx` and unmounting the entire
+world (which would trigger a redundant octree rebuild and shadow re-config), the
+game stage block and the spawn-player block are wrapped in their own
+`<Suspense fallback={null}>` boundaries inside `src/world/World.tsx`. Any new
+sibling that suspends late should be added inside one of these boundaries or get
+its own.
 
 The debug physics scene is ready when:
 

docs/technical/three-debugging.md

@@ -20,3 +20,63 @@ If DevTools still opens a bundled file, stop the dev server, clear Vite's cached
 rm -rf node_modules/.vite
 npm run dev:three-debug
 ```
+
+## Visual debug toggles
+
+The `Debug` folder of the runtime debug GUI exposes inspection toggles backed by
+`src/managers/stores/useDebugVisualsStore.ts`:
+
+- **Show Player Model** — renders the main character GLTF in front of the
+  current camera (`src/components/debug/DebugPlayerModel.tsx`). The model is
+  positioned in camera-local space so it stays visible regardless of pitch.
+- **Show Octree** — overlays the collision octree as colored line segments,
+  one wireframe per spatial cell (`src/components/debug/DebugOctreeVisualization.tsx`).
+  Cells are colored by depth. Use it to inspect collision precision around
+  doorways or passages.
+- **Octree Max Depth** — caps how deep the octree visualization recurses
+  (default 6). Increase to see leaf-level subdivisions; decrease to keep the
+  scene readable when the tree is large.
+
+The octree visualization reads the live `Octree` instance from `World`. The
+mesh uses `depthTest: false` and a high `renderOrder`, so cells stay visible
+through opaque geometry.
+
+## Shadow rendering intermittence
+
+Shadows occasionally failed to render on initial load and could disappear
+mid-session even though the `Lighting` configuration ran to completion. The
+fix has two layers:
+
+### Per-frame refresh (steady state)
+
+The sun follows the camera, so its world matrix is dirty every frame. With
+`shadow.autoUpdate` alone, three.js can skip the shadow map re-render on a
+frame where the matrix update has happened but the renderer's internal dirty
+tracking does not pick it up. To prevent that, `Lighting.useFrame` sets
+`sun.shadow.needsUpdate = true` after the per-frame matrix updates. Shadow
+config is centralized in `src/data/world/lightingConfig.ts` (`bias=0`,
+`normalBias=0`, `cameraSize=95`).
+
+### Mount-time shadow map reallocation (`useShadowMapWarmup`)
+
+The merged static map and other GLTFs mount imperatively after `Lighting`,
+so the shadow render target ends up linked to a renderer state that pre-dates
+the final scene. Materials compiled at that point bake a "no shadow map"
+permutation into their shader program and silently fail to render shadows
+until a WebGL context-restore cycle (the kind triggered by Chrome DevTools
+in `?debug` runs) reallocates everything.
+
+`src/hooks/three/useShadowMapWarmup.ts` replays that cycle programmatically
+without the cost of a full context loss. It runs a `useFrame` watchdog that
+samples the scene mesh count every 6 frames; once the count has been stable
+for ~1 s (or after a 5 s safety cap), it:
+
+1. Disposes the directional light shadow map and nulls it. three.js
+   reallocates the render target on the next render at the configured
+   `mapSize`.
+2. Marks every material's `needsUpdate = true`, forcing a shader recompile
+   that rebinds every program to the freshly created shadow sampler.
+3. Forces a single shadow pass and invalidates the renderer.
+
+The watchdog runs once per mount and adds a single traversal every 6 frames
+during the warmup window, after which it self-terminates.

docs/technical/webgl-context-lost-investigation.md

@@ -0,0 +1,367 @@
+# WebGL Context Lost - Investigation
+
+## Résumé court
+
+Le projet subit des pertes de contexte WebGL pendant les phases où le jeu active
+ou prépare le hand tracking, les interactions physiques ou le repair game.
+
+Le symptôme visible côté console est :
+
+```txt
+THREE.WebGLRenderer: Context Lost.
+[ERROR] [WebGL] Context lost - attempting auto-restore
+THREE.WebGLRenderer: Context Restored.
+```
+
+Le problème est bloquant parce que le hand tracking et le repair game sont au
+coeur de l'expérience. Quand le contexte WebGL saute, la scène Three.js peut se
+remonter, le joueur peut revenir au spawn, le pointer lock peut être perdu, et
+les tests de gameplay deviennent instables.
+
+## Ce qui fonctionne aujourd'hui
+
+La page principale monte un `<Canvas>` React Three Fiber dans
+`src/pages/page.tsx`.
+
+`src/world/World.tsx` compose ensuite :
+
+- la scène de jeu ou la scène de test physique ;
+- le player ;
+- les systèmes visuels de monde ;
+- les gants de hand tracking ;
+- les systèmes de debug.
+
+Le hand tracking est centralisé dans
+`src/providers/gameplay/HandTrackingProvider.tsx`.
+
+Il peut utiliser deux sources :
+
+- `browser` : MediaPipe JS dans le navigateur ;
+- `backend` : backend Python local via WebSocket.
+
+L'activation est déclenchée par :
+
+- certaines étapes du repair game ;
+- les zones d'interaction qui demandent explicitement les mains ;
+- la scène Physique en debug, selon les objets présents.
+
+## Problème observé
+
+Les context lost arrivent dans plusieurs situations :
+
+- entrée dans une zone d'interaction ;
+- lancement du hand tracking ;
+- lancement d'un repair game ;
+- scène Physique avec `TestMap`, `Physics`, `AnimatedModel`, waypoints GPS et
+  objets interactifs ;
+- source browser JS ;
+- source backend.
+
+Le fait que le crash existe avec les deux sources indique que le problème n'est
+probablement pas limité au backend Python ni à MediaPipe JS seul. Le hand
+tracking semble être un déclencheur fort, mais il arrive au moment où plusieurs
+ressources GPU et systèmes runtime se réveillent ensemble.
+
+## Pourquoi c'est bloquant
+
+Ce bug bloque la feature principale du projet :
+
+- le repair game dépend du hand tracking pour valider certaines actions ;
+- les interactions main sont nécessaires pour tester les objets grabbables ;
+- un context lost casse la continuité du gameplay ;
+- le joueur peut être replacé au spawn après reconstruction ;
+- le pointer lock peut être perdu ;
+- les logs deviennent difficiles à lire parce que le jeu tente de restaurer la
+  scène en boucle ;
+- le comportement n'est pas fiable pour une démo ou un déploiement.
+
+Tant que ce problème n'est pas stable, on ne peut pas valider correctement :
+
+- la mission e-bike ;
+- la mission pylône ;
+- la mission ferme ;
+- les interactions main ;
+- le switch browser/backend ;
+- le comportement en build de production.
+
+## Hypothèses principales
+
+### 1. Pression GPU au lancement du hand tracking
+
+MediaPipe browser peut créer ses propres ressources GPU. Si Three.js charge
+déjà beaucoup de géométries, textures, ombres et modèles, l'ajout du hand
+tracking peut faire passer le navigateur au-dessus d'une limite GPU.
+
+Le stash contient une tentative de mitigation en forçant MediaPipe browser et le
+backend à utiliser le CPU.
+
+### 2. Activation trop brusque du runtime mains
+
+Les logs montrent des transitions rapides :
+
+```txt
+Browser JS runtime starting
+Runtime source selected
+Runtime snapshot changed
+Browser JS runtime stopped
+Browser JS runtime starting
+```
+
+Ce type de start/stop rapide peut provoquer :
+
+- création webcam ;
+- création MediaPipe ;
+- montage des gants ;
+- update du state React ;
+- re-render du monde ;
+- stress GPU au même moment.
+
+### 3. Les gants 3D sont montés trop tôt
+
+Si les gants de hand tracking sont montés avant d'avoir de vraies mains
+détectées, le jeu charge et prépare des modèles GPU sans utilité immédiate.
+
+Le stash contient une tentative pour ne rendre les gants que lorsqu'une main
+existe réellement dans le snapshot.
+
+### 4. Re-upload textures / GLTF trop agressif
+
+`src/utils/three/optimizeGLTFScene.ts` modifie des textures GLTF. Si cette
+optimisation force trop souvent `needsUpdate`, mipmaps ou anisotropy, le
+navigateur peut recharger beaucoup de textures vers le GPU.
+
+Le stash limite cette pression en évitant de forcer les mipmaps et en abaissant
+l'anisotropy.
+
+### 5. Permission caméra au mauvais moment
+
+Demander la caméra au moment exact où le joueur entre dans une interaction ou
+lance le repair game ajoute un gros événement runtime au pire moment.
+
+Le stash contient une tentative de warmup caméra pour obtenir la permission plus
+tôt et réutiliser le stream au moment où le hand tracking devient nécessaire.
+
+### 6. La scène Physique ajoute du bruit
+
+La scène Physique est une scène de test volontairement riche :
+
+- `Physics` Rapier ;
+- `GrabbableObject` ;
+- `TriggerObject` ;
+- `RepairGame` ;
+- `AnimatedModel` ;
+- GPS preview ;
+- waypoints verts ;
+- player ;
+- debug overlay.
+
+Cette richesse est normale pour une scène de test, mais elle complique
+l'investigation parce qu'elle active beaucoup de systèmes à la fois.
+
+## Fichiers modifiés dans le stash
+
+Le stash `stash@{0}` contient 28 fichiers modifiés, environ `+530 / -152`.
+Il ne contient pas de fichiers untracked.
+
+| Fichier                                                   | Rôle dans l'investigation                                                                 |
+| --------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
+| `README.md`                                               | Note sur les commandes backend depuis la racine du repo.                                  |
+| `backend/README.md`                                       | Documentation plus claire pour lancer le backend et réparer un `.venv` cassé.             |
+| `backend/hand_tracker.py`                                 | Force le backend MediaPipe en CPU.                                                        |
+| `docs/user/main-feature.md`                               | Ajustements de documentation utilisateur.                                                 |
+| `public/sounds/dialogue/subtitles/fr/electricienne.srt`   | Ajustements de sous-titres, pas central pour le context lost.                             |
+| `public/sounds/dialogue/subtitles/fr/narrateur.srt`       | Ajustements de sous-titres, pas central pour le context lost.                             |
+| `src/components/debug/DebugPlayerModel.tsx`               | Ajustements de modèle debug player.                                                       |
+| `src/components/three/handTracking/HandTrackingGlove.tsx` | Retire le preload automatique des gants pour réduire la pression GPU.                     |
+| `src/components/three/interaction/GrabbableObject.tsx`    | Marque les grabbables qui nécessitent vraiment le hand tracking.                          |
+| `src/components/three/interaction/InteractableObject.tsx` | Ajoute le flag `handTracking` aux interactables.                                          |
+| `src/data/debug/testSceneConfig.ts`                       | Stabilise la scène Physique : sol, GPS, hauteur des waypoints.                            |
+| `src/data/handTrackingConfig.ts`                          | Ajoute délai d'activation, TTL warmup caméra, delegate CPU browser.                       |
+| `src/data/player/playerConfig.ts`                         | Corrige le spawn Physique avec `PLAYER_EYE_HEIGHT`.                                       |
+| `src/hooks/debug/useSceneMode.ts`                         | Force `game` hors debug actif pour éviter des scènes debug en prod.                       |
+| `src/hooks/handTracking/useBothFistsHold.ts`              | Sort le hold des deux poings de `useFrame` R3F vers `requestAnimationFrame`.              |
+| `src/hooks/handTracking/useBrowserHandTracking.ts`        | Encadre `detectForVideo`, release MediaPipe en cleanup, gère les erreurs.                 |
+| `src/hooks/three/useTerrainHeight.ts`                     | Ajustements terrain, liés au snap/player.                                                 |
+| `src/lib/handTracking/browserHandTracking.ts`             | Force delegate CPU, garde une instance MediaPipe, ajoute `releaseBrowserHandLandmarker`.  |
+| `src/lib/handTracking/handTrackingSession.ts`             | Ajoute warmup caméra, cache stream, timeout et consommation du stream préparé.            |
+| `src/managers/InteractionManager.ts`                      | Ajoute `handTrackingNearby` pour ne pas activer les mains sur toute interaction.          |
+| `src/pages/page.tsx`                                      | Gestion WebGL context lost/restored, DPR fixe, antialias off, release MediaPipe au crash. |
+| `src/providers/gameplay/HandTrackingProvider.tsx`         | Ajoute activation différée, snapshot queued, warmup runtime.                              |
+| `src/types/interaction/interaction.ts`                    | Ajoute `handTracking` et `handTrackingNearby` aux types interaction.                      |
+| `src/utils/debug/Debug.ts`                                | Synchronise l'affichage du controller hand tracking source.                               |
+| `src/utils/three/optimizeGLTFScene.ts`                    | Réduit la pression GPU des textures GLTF.                                                 |
+| `src/world/World.tsx`                                     | Ne rend les gants que si une main correspondante est détectée.                            |
+| `src/world/debug/TestMap.tsx`                             | Nettoie les logs, stabilise waypoints/GPS/scène Physique.                                 |
+| `src/world/player/PlayerCamera.tsx`                       | Ajustements pointer lock/canvas ciblé.                                                    |
+
+## Fichiers actuellement modifiés dans le worktree
+
+Etat observé au moment de cette note :
+
+| Fichier                                                   | Statut                                                    |
+| --------------------------------------------------------- | --------------------------------------------------------- |
+| `public/models/talkie/*`                                  | Beaucoup d'anciennes textures/fichiers `.gltf` supprimés. |
+| `public/models/talkie/model.glb`                          | Nouveau fichier non suivi.                                |
+| `src/components/three/handTracking/HandTrackingGlove.tsx` | Modifié.                                                  |
+| `src/data/debug/testSceneConfig.ts`                       | Modifié.                                                  |
+| `src/data/gameplay/repairMissions.ts`                     | Modifié.                                                  |
+| `src/data/handTrackingConfig.ts`                          | Modifié.                                                  |
+| `src/data/player/playerConfig.ts`                         | Modifié.                                                  |
+| `src/data/world/mapLodConfig.ts`                          | Modifié.                                                  |
+| `src/hooks/handTracking/useBrowserHandTracking.ts`        | Modifié.                                                  |
+| `src/hooks/handTracking/useRemoteHandTracking.ts`         | Modifié.                                                  |
+| `src/lib/handTracking/browserHandTracking.ts`             | Modifié.                                                  |
+| `src/lib/handTracking/handTrackingSession.ts`             | Modifié.                                                  |
+| `src/pages/page.tsx`                                      | Modifié.                                                  |
+| `src/providers/gameplay/HandTrackingProvider.tsx`         | Modifié.                                                  |
+| `src/utils/debug/Debug.ts`                                | Modifié.                                                  |
+| `src/utils/three/optimizeGLTFScene.ts`                    | Modifié.                                                  |
+| `src/world/World.tsx`                                     | Modifié.                                                  |
+| `src/world/debug/TestMap.tsx`                             | Modifié.                                                  |
+| `src/world/player/Player.tsx`                             | Modifié.                                                  |
+| `src/world/player/PlayerCamera.tsx`                       | Modifié.                                                  |
+| `src/world/player/PlayerController.tsx`                   | Modifié.                                                  |
+| `src/components/ui/RuntimeLoadingIndicator.tsx`           | Nouveau fichier non suivi.                                |
+| `src/hooks/handTracking/useHandTrackingRuntimeWarmup.ts`  | Nouveau fichier non suivi.                                |
+| `src/world/player/playerRuntimeSnapshot.ts`               | Nouveau fichier non suivi.                                |
+
+Attention : les fichiers supprimés/nouveaux du talkie semblent être un sujet
+séparé du context lost. Il faut les garder séparés dans les commits.
+
+## Fichiers directement impactés par le bug
+
+### Canvas et WebGL
+
+- `src/pages/page.tsx`
+- `src/world/World.tsx`
+- `src/utils/three/optimizeGLTFScene.ts`
+
+Ces fichiers influencent directement la charge GPU, la configuration du canvas,
+les ressources GLTF et le comportement au context lost/restored.
+
+### Hand tracking
+
+- `src/providers/gameplay/HandTrackingProvider.tsx`
+- `src/hooks/handTracking/useBrowserHandTracking.ts`
+- `src/hooks/handTracking/useRemoteHandTracking.ts`
+- `src/hooks/handTracking/useBothFistsHold.ts`
+- `src/hooks/handTracking/useHandTrackingRuntimeWarmup.ts`
+- `src/lib/handTracking/browserHandTracking.ts`
+- `src/lib/handTracking/handTrackingSession.ts`
+- `src/data/handTrackingConfig.ts`
+- `src/components/three/handTracking/HandTrackingGlove.tsx`
+- `backend/hand_tracker.py`
+
+Ces fichiers contrôlent le déclenchement, la source, la caméra, MediaPipe, le
+backend et le rendu visuel des mains.
+
+### Interactions et repair game
+
+- `src/components/three/interaction/GrabbableObject.tsx`
+- `src/components/three/interaction/InteractableObject.tsx`
+- `src/managers/InteractionManager.ts`
+- `src/types/interaction/interaction.ts`
+- `src/components/three/gameplay/RepairGame.tsx`
+- `src/hooks/gameplay/useRepairMissionStep.ts`
+- `src/hooks/gameplay/useRepairMovementLocked.ts`
+
+Ces fichiers sont impactés parce que l'entrée dans une zone ou une étape repair
+peut déclencher le hand tracking.
+
+### Player et restauration après crash
+
+- `src/world/player/Player.tsx`
+- `src/world/player/PlayerCamera.tsx`
+- `src/world/player/PlayerController.tsx`
+- `src/world/player/playerRuntimeSnapshot.ts`
+- `src/data/player/playerConfig.ts`
+
+Ces fichiers influencent le spawn, la caméra, le pointer lock, et la possibilité
+de récupérer la dernière position après un context lost.
+
+### Scène Physique / debug
+
+- `src/world/debug/TestMap.tsx`
+- `src/data/debug/testSceneConfig.ts`
+- `src/components/debug/DebugPlayerModel.tsx`
+- `src/hooks/debug/useSceneMode.ts`
+- `src/utils/debug/Debug.ts`
+
+Ces fichiers ne sont pas forcément la cause racine, mais ils créent une scène de
+stress utile pour reproduire le bug.
+
+## Ce que le stash essayait de corriger
+
+Le stash essaye de réduire le risque de context lost avec plusieurs leviers :
+
+1. passer MediaPipe browser/backend en CPU ;
+2. libérer MediaPipe quand le runtime s'arrête ou quand WebGL saute ;
+3. éviter de monter les gants sans mains détectées ;
+4. retarder l'activation du hand tracking pour éviter les start/stop violents ;
+5. demander la caméra plus tôt et réutiliser le stream ;
+6. réduire la charge GPU du canvas avec DPR fixe et antialias off ;
+7. limiter les re-uploads de textures GLTF ;
+8. distinguer les interactions qui demandent vraiment le hand tracking ;
+9. restaurer WebGL avec une limite pour éviter les boucles infinies ;
+10. conserver la position du joueur après restauration.
+
+## Ce qui reste à prouver
+
+Il faut encore isoler le déclencheur exact :
+
+- crash avec hand tracking désactivé complètement ;
+- crash avec source browser JS seulement ;
+- crash avec source backend seulement ;
+- crash avec gants 3D désactivés ;
+- crash avec MediaPipe CPU ;
+- crash avec `AnimatedModel` de TestMap désactivé ;
+- crash avec GPS preview/waypoints désactivés ;
+- crash avec shadows/antialias/DPR réduits ;
+- crash en scène game réelle, pas seulement scène Physique.
+
+## Plan d'investigation recommandé
+
+1. Stabiliser le worktree et ne pas mélanger assets talkie, LOD, docs backend et
+   context lost dans le même commit.
+2. Garder le stash tant que le fix final n'est pas validé.
+3. Créer un commit ou patch isolé pour les logs context lost seulement.
+4. Ajouter un switch debug qui permet de couper séparément :
+   - hand tracking runtime ;
+   - gants 3D ;
+   - MediaPipe browser ;
+   - backend ;
+   - GPS preview ;
+   - AnimatedModel de TestMap.
+5. Reproduire le bug avec une matrice claire.
+6. Garder les changements qui diminuent réellement les context lost.
+7. Supprimer les logs temporaires une fois le diagnostic terminé.
+
+## Recommandation Git
+
+Ne pas supprimer le stash maintenant.
+
+Il contient du travail réel sur le context lost. Même s'il n'est pas parfait, il
+sert de trace d'investigation et contient des morceaux utiles.
+
+Avant de le supprimer, sauvegarder le patch :
+
+```bash
+git stash show -p stash@{0} > context-lost-stash.patch
+```
+
+Ensuite seulement, si tout a été repris dans des commits propres :
+
+```bash
+git stash drop stash@{0}
+```
+
+## Commits logiques proposés
+
+Séparer en plusieurs commits pour éviter un gros commit illisible :
+
+1. `docs: document webgl context lost investigation`
+2. `fix: reduce handtracking gpu pressure`
+3. `fix: delay handtracking activation`
+4. `fix: preserve player state after webgl restore`
+5. `fix: stabilize physics debug scene`
+6. `docs: clarify backend handtracking setup`