0.3.1-0-pre.2.fix.2

Android/game-reflex-poc/build.gradle

@@ -1,5 +1,5 @@
 // file: Android/game-reflex-poc/build.gradle
-// version: 24
+// version: 45
 
 plugins {
     id 'com.android.application'
@@ -17,8 +17,8 @@ android {
         applicationId 'com.sasedev.games.reflex'
         minSdk 21
         targetSdk 36
-        versionCode 1
+        versionCode 2
-        versionName '0.1.0'
+        versionName '0.2.0'
     }
 
     compileOptions {

Android/game-snake-poc/build.gradle

@@ -1,5 +1,5 @@
 // file: Android/game-snake-poc/build.gradle
-// version: 24
+// version: 45
 
 plugins {
     id 'com.android.application'
@@ -17,8 +17,8 @@ android {
         applicationId 'com.sasedev.games.snake'
         minSdk 21
         targetSdk 36
-        versionCode 1
+        versionCode 2
-        versionName '0.1.0'
+        versionName '0.2.0'
     }
 
     compileOptions {

CHANGELOG.md

@@ -1,16 +1,48 @@
 <!-- file: CHANGELOG.md -->
-<!-- version: 8 -->
+<!-- version: 14 -->
 
 # Changelog
 
+## 0.3.0 — 2026-09-20
+
+- publication stable du premier POC Snake Web direct, construit autour du gameplay Rust partagé, d'un adapter WASM dédié et d'un host navigateur Vite/TypeScript ;
+- validation du shell Bootstrap 5/Bootswatch + SimpleBar, du Canvas au ratio logique `12 × 20`, des contrôles clavier/pointer, du lifecycle navigateur, des assets et de la provenance runtime ;
+- validation de la non-régression Desktop SDL3 et des builds release Desktop et Web/WASM ;
+- promotion mécanique de `0.3.0-3-rc.1` après gate workspace complète, 34 tests réussis et absence de défaut nécessitant un correctif RC ;
+- préparation de `0.3.1` pour le second host Snake Tauri Android, sans ouvrir ce scope dans la release `0.3.0`.
+
+Les détails des phases `pre`, `beta`, `rc` et de leurs correctifs restent dans `deltas/0.3.0/` et `history/0.3.0/`.
+
+## 0.3.0-3-rc.1 — 2026-09-20
+
+- gel fonctionnel du premier POC Snake Web direct après validation beta et consolidation documentaire ;
+- gameplay Snake conservé dans `game-snake-poc`, avec adapter `game-snake-poc-wasm` dédié et host navigateur Vite/TypeScript séparé ;
+- shell Web responsive fondé sur Bootstrap 5/Bootswatch, SimpleBar et Canvas au ratio logique du jeu, avec clavier et contrôles pointer/tactiles ;
+- lifecycle navigateur fixed-step sans rattrapage massif, resize `devicePixelRatio`, assets `common/` + `game/`, logging frontend structuré et provenance `Web / Browser / Wasm` ;
+- runner Desktop SDL3 maintenu comme témoin de non-régression et builds release Desktop/Web déjà exercés pendant la beta ;
+- prompt `0.3.1` préparé pour le second host Snake Tauri Android, avec workflow de session, commandes et validations consolidés.
+
+La RC n'ouvre aucun nouveau scope. Les détails des phases `pre`, `beta` et de leurs correctifs restent dans `deltas/0.3.0/` et `history/0.3.0/`.
+
+## 0.2.0 — conception modulaire, POC et Uroburas
+
+- Gouvernance documentaire renforcée : catégories `ideas/studies/architecture/rules`, immutabilité des deltas, conventions de statuts et workflow de session/version.
+- Architecture durable séparant engine kernel, technical capabilities, game-systems, games, platform adapters, providers, server services et tooling.
+- Trajectoire POC `0.3.x` définie avec Snake comme jeu-sonde pour SDL, Web/WASM, Tauri et transports realtime.
+- Architecture réseau de référence : Actix Web/Maud/Fluent/Lettre pour Web/API, WebSocket/tokio-tungstenite baseline, WebTransport/QUIC candidat, gRPC/Tonic conditionnel server-to-server.
+- Asset delivery auto-hébergé, compatible HTTP/2 et HTTP/3 selon disponibilité, avec séparation logique puis physique progressive.
+- Cible d'exploitation préférée : Debian Stable, actuellement Debian 13 `trixie`, sans dépendance métier à une version précise.
+- Spécification fonctionnelle et architecture cible initiales de Uroburas, avec ordre Mode 1 Challenge → Mode 3 Persistent Battle Royale → Mode 2 PvP Battles.
+- Classification des besoins Uroburas afin d'éviter une crate jeu monolithique.
+- Première trajectoire Uroburas réservant grid/tilemap toroïdale, obstacles, stages, vies, score, caméra, assets téléchargeables, auth, rewarded ads, Hall of Fame et échanges client/serveur sécurisés/versionnés.
+
 ## 0.1.0 — 2026-09-17
 
 - validation de `0.1.0-3-rc.1.fix.1` avec gates Rust/audits complètes, builds et smokes Desktop release, Tauri/WASM, Android x86_64/API 36 et Android ARM64 réel ;
 - stabilisation d'une première baseline POC multi-plateforme fondée sur un core de gameplay Rust réutilisé par des runners SDL3 Desktop/Android et un POC Tauri/WebView/WASM ;
 - validation de l'abstraction d'input, du rendu 2D minimal, des assets, de la provenance runtime, du tracing commun et du lifecycle/Back Android ;
 - clôture du cycle POC `0.1.0` sans ajout fonctionnel de dernière minute ;
-- réservation de la direction `0.2.0` : petit kernel moteur, capabilities séparées, adaptateurs plateforme, providers, jeux et services/serveurs composés statiquement ;
+- réservation de la direction `0.2.0` pour concevoir progressivement le framework modulaire avant toute extension fonctionnelle majeure.
-- ajout d'un prompt de conception `0.2.0` afin que l'inventaire détaillé des fonctionnalités et la future architecture soient discutés avant toute implémentation majeure.
 
 ## 0.1.0-3-rc.1 — 2026-09-17
 
@@ -20,59 +52,4 @@
 - entrée en phase RC centrée sur la reproductibilité des builds de release, les artefacts de distribution et la documentation de livraison ;
 - ajout d'une matrice RC et d'une gate workspace complète avant promotion vers `0.1.0`.
 
-## 0.1.0-2-beta.1 — 2026-09-17
+Les détails des phases `pre`, `alpha`, `beta` et de leurs correctifs sont conservés dans `deltas/0.1.0/` et `history/0.1.0/`.
-
-- validation de `1-alpha.2.fix.5` avec Reflex exécuté dans Tauri/WebView/WASM via Vite + TypeScript ;
-- validation du tracing unifié Rust/TypeScript et de la sortie `Escape` via le contrat moteur commun ;
-- passage en phase beta, désormais centrée sur la stabilisation, le packaging et les tests multi-appareils ;
-- ajout d'une matrice de validation Desktop SDL3, Tauri/WASM, Android AVD x86_64 et Android ARM64 réel ;
-- ajout d'un audit en lecture seule des frontières statiques nécessaires aux distributions ;
-- formalisation des gates de packaging Desktop natif, Tauri et Android beta.
-
-## 0.1.0-1-alpha.1 — 2026-09-16
-
-- validation de la fin de phase `0-pre.*` avec Snake jouable sur Desktop et Galaxy S9+ ARM64 ;
-- stabilisation du contrat de sortie `QuitRequest` / `QuitDecision` introduit pendant les derniers correctifs `0-pre.11` ;
-- introduction de `RuntimeProvenance` dans `engine-v1-platform-api` ;
-- séparation explicite entre famille de plateforme, classe de device, exécution native/WASM, hôte runtime et profil d'entrée ;
-- préparation des futurs leaderboards/Hall of Fame pour segmenter les scores selon l'environnement sans imposer de comparaison automatique ;
-- planification d'un POC Web/WASM dans Tauri comme prochain jalon alpha.
-
-## 0.1.0-0-pre.4 — 2026-09-16
-
-- validation de `0-pre.3` enregistrée avec suite workspace complète et smokes Desktop propres ;
-- déplacement des tests unitaires hors `src/` vers `unit_tests/` et formalisation de `tests/` pour intégration/environnement ;
-- ajout d’un audit empêchant le retour de corps de tests sous `src/` ;
-- adoption des tests Cargo ciblés par défaut, la suite workspace complète devenant une gate lourde périodique ;
-- `cargo fmt --all` devient obligatoire avant la gate lorsqu’un delta modifie du Rust, sans incrément d’en-tête pour les seules modifications rustfmt ;
-- introduction de `game-logging-lib` avec `tracing`, `tracing-subscriber` et `tracing-appender` ;
-- initialisation du tracing dans les runners Desktop et helper de tracing local pour les tests.
-
-## 0.1.0-0-pre.3 — 2026-09-16
-
-- validation utilisateur de `0.1.0-0-pre.2` avec formatage, audits, check, Clippy strict et tests workspace propres ;
-- introduction de `EngineFrame`, `InputState`, `EngineGame` et `FixedStepRunner` comme première boucle moteur indépendante de SDL3 ;
-- branchement des deux POC et des deux runners Desktop sur cette boucle commune ;
-- introduction d'un état explicite `Available` / `Disabled` / `Unsupported` pour les services plateforme optionnels et d'une déclaration de capacités de monétisation ;
-- documentation de la monétisation optionnelle par plateforme, y compris distinction Android, Web et Desktop ;
-- documentation du binaire Desktop SDL3 comme défaut et d'une variante Tauri optionnelle sans duplication du gameplay ;
-- formalisation de la validation Cargo par l'utilisateur, de l'enregistrement de la validation du delta précédent et du passage automatique au delta suivant ou à un `.fix.N` selon le résultat.
-
-## 0.1.0-0-pre.2 — 2026-09-15
-
-- intégration de l'architecture de référence dans une documentation thématique durable ;
-- ajout des objectifs projet, classification des jeux, abstraction SDL3 multi-plateforme, contrôles, assets, évolution moteur, monétisation et services en ligne ;
-- ajout d'une crate binaire Desktop par POC, chacune consommant exclusivement la crate lib du jeu correspondant ;
-- ajout de la politique normative des commandes Cargo, audits, runners, Android, Web et Git ;
-- mise à jour de l'index documentaire, des contrats de fichiers, de la roadmap et des gates.
-
-## 0.1.0-0-pre.1 — 2026-09-15
-
-- création du workspace Cargo multi-crates ;
-- introduction de la génération `engine-v1` ;
-- création de deux POC structurels Reflex et Snake ;
-- séparation stricte des assets hors crates ;
-- création de la structure Android Java commune et spécifique par jeu ;
-- adaptation des règles et audits issus de l'expérience KSP ;
-- adoption du cycle SemVer `pre -> alpha -> beta -> rc -> stable` avec correctifs `.fix.N` ;
-- adoption des livraisons par archives delta.

Cargo.toml

@@ -1,5 +1,5 @@
 # file: Cargo.toml
-# version: 36
+# version: 73
 
 [workspace]
 resolver = "3"
@@ -16,10 +16,12 @@ members = [
     "crates/apps/game-android-entrypoint",
     "crates/apps/game-reflex-poc-tauri",
     "crates/apps/game-reflex-poc-wasm",
+    "crates/apps/game-snake-poc-wasm",
+    "crates/apps/game-snake-poc-tauri",
 ]
 
 [workspace.package]
-version = "0.1.0"
+version = "0.3.1-0-pre.2.fix.2"
 edition = "2024"
 license = "MIT"
 repository = "https://git.sasedev.com/Sasedev/games"

README.md

@@ -1,5 +1,5 @@
 <!-- file: README.md -->
-<!-- version: 6 -->
+<!-- version: 44 -->
 
 # games.sasedev
 
@@ -14,6 +14,7 @@ Workspace expérimental puis productif pour des jeux multiplateformes principale
 - assets hors des crates sous `assets/` ;
 - `assets/common/` pour les ressources mutualisées et un répertoire par jeu pour les ressources spécifiques ;
 - frontend Android sous `Android/`, en Java, avec une partie commune et une partie spécifique par jeu ;
+- hosts navigateur directs sous `Web/`, avec frontend Vite/TypeScript séparé des adapters Rust/WASM ;
 - monétisation optionnelle et spécifique à chaque plateforme/distribution ;
 - runner Desktop natif SDL3 par défaut, avec variante Tauri uniquement si un besoin futur la justifie ;
 - documentation sous `docs/` ;
@@ -23,7 +24,9 @@ Workspace expérimental puis productif pour des jeux multiplateformes principale
 
 ## Baseline
 
-Version courante : `0.1.0-1-alpha.1`.
+Version stable de référence : `0.3.0`.
+
+Version de développement courante : `0.3.1-0-pre.2.fix.2`.
 
 Les deux premiers jeux sont des POC structurels : `game-reflex-poc` et `game-snake-poc`. Ils existent d'abord pour valider les frontières du workspace, le moteur, les assets et le packaging multiplateforme.
 

ROADMAP.md

@@ -1,27 +1,56 @@
 <!-- file: ROADMAP.md -->
-<!-- version: 14 -->
+<!-- version: 21 -->
 
 # Roadmap
 
+## Légende
+
+- `( )` — planned ;
+- `(x)` — completed ;
+- `(d)` — deferred ;
+- `(c)` — cancelled.
+
+Les marqueurs qualifient une ligne de scope. Une même version peut donc apparaître plusieurs fois si une partie est livrée, une partie reportée et une autre annulée.
+
 ## 0.1.0 — Fondation POC
 
-- [x] `0-pre.1` — squelette du workspace, règles, architecture, versions, assets, Java Android commun/spécifique et deux crates POC.
+- (x) `0.1.0` — squelette du workspace, règles, architecture, versions et assets.
-- [x] `0-pre.2` — consolidation documentaire issue de l'architecture de référence, runners Desktop par jeu et politique normative des commandes.
+- (x) `0.1.0` — moteur V1 POC, boucle de jeu, input abstrait et rendu SDL3 minimal.
-- [x] `0-pre.3` — première boucle moteur exécutable Desktop : temps, input abstrait, capacités de monétisation optionnelles et état de jeu minimal via les runners.
+- (x) `0.1.0` — Reflex et Snake jouables comme POC de réutilisation.
-- [x] `0-pre.4` — architecture de tests hors `src/`, stratégie de tests ciblés et socle `tracing`/`tracing-subscriber`/`tracing-appender`.
+- (x) `0.1.0` — Desktop SDL3 natif, Android SDL3/Java/JNI et Tauri/WebView/WASM Reflex.
-- [x] `0-pre.5` — intégration SDL3 Desktop réelle et premier rendu POC Reflex.
+- (x) `0.1.0` — tracing commun, provenance runtime, packaging et validation multi-appareils.
-- [x] `0-pre.6` — fondation Gradle Android, SDL3 AAR, Activity Java commune et politique de fenêtre Desktop redimensionnable.
+
-- [x] `0-pre.7` — compilation Rust Android `cdylib`, point d'entrée SDL Android et premier lancement APK sur appareil/émulateur.
+Le détail historique des prereleases `0.1.0-*` reste dans `deltas/0.1.0/` et `history/0.1.0/`.
-- [x] `0-pre.8` — bridge Java/JNI minimal et input tactile Android.
-- [x] `0-pre.9` — assets communs + spécifiques empaquetés sans copie dans les crates.
-- [x] `0-pre.10` — POC Reflex jouable Desktop + Android.
-- [x] `0-pre.11` — POC Snake jouable et validation de la réutilisation du moteur.
-- [x] `1-alpha.1` — première API moteur V1 volontairement stabilisée et provenance runtime/input pour les futures sessions et scores.
-- [x] `1-alpha.2` — POC Web/WASM embarqué dans Tauri, sans site distant, et validation de la frontière des services Web/ads.
-- [x] `2-beta.1` — stabilisation, packaging, tests multi-appareils.
-- [x] `3-rc.1` — candidat de release du socle 0.1.0.
-- [x] `0.1.0` — première baseline stable du framework POC.
 
 ## 0.2.0 — Conception du framework modulaire
 
-- [ ] `0.2.0` — inventorier et réserver les capabilities utiles, définir les couches et dépendances autorisées, établir la matrice plateformes et les archétypes de jeux, définir la composition statique et l'architecture cible des crates, puis seulement planifier les implémentations progressives.
+- (x) `0.2.0` — fixer la gouvernance documentaire, la nomenclature et le cycle de maturation des idées et décisions.
+- (x) `0.2.0` — inventorier et réserver les capabilities déjà justifiées sans les implémenter prématurément.
+- (x) `0.2.0` — définir les couches, les dépendances autorisées et la frontière entre kernel, capability, plateforme, provider, système de jeu et service.
+- (x) `0.2.0` — établir la matrice plateformes et les archétypes de jeux utilisés pour challenger l'architecture.
+- (x) `0.2.0` — retenir la composition Rust statique comme direction de référence.
+- (d) `0.2.0` — figer un manifest produit/jeu et l'architecture physique définitive des crates → target TBD après observation des POC `0.3.x`.
+- (x) `0.2.0` — définir la trajectoire d'implémentation progressive `0.3.x` POC puis `0.4.x` Uroburas.
+- (x) `0.2.0` — consolider les études acceptées en architecture/règles durables, notamment ownership, réseau, Uroburas et POC, puis fermer les points encore candidats.
+- (x) `0.2.0` — formaliser la stratégie réseau : Actix Web pour le Web/API, asset delivery auto-hébergé H2/H3, WebSocket baseline et WebTransport/QUIC candidat.
+- (x) `0.2.0` — préparer une trajectoire `0.3.x` dédiée aux POC plateforme/réseau avec Snake comme jeu-sonde.
+- (x) `0.2.0` — préparer la trajectoire `0.4.x` Uroburas Mode 1 et le prompt de session associé après gel de la conception.
+
+## 0.3.0 — Baseline Snake + premier POC Web direct
+
+- (x) `0.3.0` — nettoyer la baseline Snake sans introduire de logique Uroburas et maintenir le runner Desktop SDL3 fonctionnel.
+- (x) `0.3.0` — produire une adaptation WASM dédiée à Snake sans déplacer le gameplay hors de `game-snake-poc`.
+- (x) `0.3.0` — réaliser un POC navigateur direct Snake couvrant clavier, boutons directionnels tactiles, resize, lifecycle, logging, assets et provenance runtime.
+- (x) `0.3.0` — utiliser uniquement Cargo, `wasm-bindgen` et Vite/npm pour le chemin de build Web ; aucun script Python ne pilote ce build.
+- (x) `0.3.0` — documenter les duplications observées et conserver les adapters Web/WASM spécifiques tant qu’un second consommateur ne justifie pas une extraction commune.
+
+## Série 0.3.x — trajectoire actuelle après 0.3.0
+
+- ( ) `0.3.1` — second host Snake : Tauri Android, en réutilisant la baseline Web/WASM validée et en remplaçant toute orchestration Python du chemin touché.
+- ( ) `0.3.2` — Tauri Desktop + Snake et factorisation WebView uniquement lorsque deux consommateurs réels justifient l'extraction.
+- ( ) `0.3.3` — Android SDL natif multi-ABI avec Cargo/Gradle natifs, sans script Python de build.
+- ( ) `0.3.4` — API de transport realtime + WebSocket/tokio-tungstenite baseline, sans serveur Uroburas Mode 3.
+- ( ) `0.3.5` — POC WebTransport/QUIC sur le même protocole, avec comparaison mesurée et fallback WebSocket.
+- ( ) `0.3.6` — consolidation des POC plateforme/réseau et préparation de la baseline `0.4.x`.
+
+La numérotation `0.3.1+` reste révisable à partir des résultats réels ; les lignes ci-dessus décrivent le planning actuel, pas une obligation de créer des versions artificielles.

RULES.md

@@ -1,5 +1,5 @@
 <!-- file: RULES.md -->
-<!-- version: 3 -->
+<!-- version: 5 -->
 
 # Index normatif games.sasedev
 
@@ -15,7 +15,11 @@ Les règles détaillées sont maintenues sous `docs/rules/` et sont cumulatives
 4. [`docs/rules/RULES_DOCUMENTATION.md`](docs/rules/RULES_DOCUMENTATION.md) — règles Markdown et cycle documentaire ;
 5. [`docs/rules/FILE_CONTRACTS.md`](docs/rules/FILE_CONTRACTS.md) — responsabilités des principales familles de fichiers ;
 6. [`docs/rules/VERSION_WORKFLOW.md`](docs/rules/VERSION_WORKFLOW.md) — SemVer, niveaux de maturité, fixes, deltas et livraisons ;
-7. [`docs/rules/RULES_COMMANDS.md`](docs/rules/RULES_COMMANDS.md) — politique d’exécution des commandes Cargo, audits, runners, Android, Web et Git.
+7. [`docs/rules/RULES_COMMANDS.md`](docs/rules/RULES_COMMANDS.md) — politique d’exécution des commandes Cargo, audits, runners, Android, Web et Git ;
+8. [`docs/rules/RULES_VALIDATION_MATRIX.md`](docs/rules/RULES_VALIDATION_MATRIX.md) — matrice évolutive des commandes, dépendances de validation et politiques de nettoyage ;
+9. [`docs/rules/RULES_SESSION_PLANNING.md`](docs/rules/RULES_SESSION_PLANNING.md) — cadrage `pre.1`, dimensionnement des sessions et cycle de transmission ;
+10. [`docs/rules/PROMPT_STRUCTURE.md`](docs/rules/PROMPT_STRUCTURE.md) — structure minimale des prompts de reprise et rappels de workflow obligatoires ;
+11. [`docs/rules/RULES_SERVER_HOSTING.md`](docs/rules/RULES_SERVER_HOSTING.md) — contraintes durables de portabilité et préférence d'auto-hébergement.
 
 ## Hiérarchie
 

Web/game-snake-poc/frontend/main.html

@@ -0,0 +1,118 @@
+<!-- file: Web/game-snake-poc/frontend/main.html -->
+<!-- version: 4 -->
+<!DOCTYPE html>
+<html lang="fr">
+
+    <head>
+        <meta charset="utf-8">
+        <meta content="width=device-width, initial-scale=1.0, viewport-fit=cover" name="viewport">
+        <meta content="#593196" name="theme-color">
+        <link rel="stylesheet" href="sass/main.scss">
+        <title>Snake POC — Web direct</title>
+    </head>
+
+    <body>
+        <header class="app-header">
+            <nav class="navbar h-100 py-0 bg-light text-dark">
+                <div class="container-fluid px-3 px-md-4 flex-nowrap">
+                    <div class="navbar-brand d-flex align-items-center me-3 flex-nowrap min-w-0">
+                        <span class="app-logo d-inline-flex align-items-center justify-content-center text-primary" aria-hidden="true">
+                            <i class="fa-solid fa-gamepad"></i>
+                        </span>
+                        <span class="ps-2 fs-4 fw-semibold text-primary text-nowrap">Snake POC</span>
+                        <span class="mx-2 fs-5 text-body-secondary d-none d-sm-inline" aria-hidden="true">—</span>
+                        <span class="fs-5 text-body text-nowrap d-none d-sm-inline">Web direct</span>
+                    </div>
+                    <div class="d-flex align-items-center gap-2 ms-auto">
+                        <span class="badge text-bg-light border text-dark d-none d-md-inline">Rust/WASM</span>
+                        <span id="runtime-status" class="badge text-bg-secondary" role="status" aria-live="polite">Initialisation…</span>
+                    </div>
+                </div>
+            </nav>
+        </header>
+
+        <main class="app-main container-fluid p-0">
+            <div class="row g-0 h-100 flex-nowrap">
+                <section class="col app-content app-scrollable h-100" data-simplebar>
+                    <div class="container-fluid px-3 px-md-4 py-3 py-md-4">
+                    <div class="card app-shell-card mx-auto shadow-sm border-0">
+                        <div class="card-body p-3 p-md-4">
+                            <div class="d-flex align-items-start justify-content-between gap-3 flex-wrap mb-3">
+                                <div>
+                                    <h1 class="h3 mb-1">Snake</h1>
+                                    <p class="text-body-secondary mb-0">Gameplay Rust portable, adapter WebAssembly et rendu Canvas piloté par TypeScript.</p>
+                                </div>
+                                <div class="d-flex gap-2 flex-wrap" aria-label="État de la partie">
+                                    <output id="score" class="badge text-bg-primary">Score : 0</output>
+                                    <output id="length" class="badge text-bg-info">Longueur : 0</output>
+                                </div>
+                            </div>
+
+                            <div class="row g-3 g-lg-4 align-items-start">
+                                <div class="col-12 col-lg-8">
+                                    <div class="card border-primary-subtle shadow-sm">
+                                        <div class="card-body p-2 p-sm-3">
+                                            <div class="game-stage">
+                                                <canvas id="game" width="640" height="640" tabindex="0" aria-label="Zone de jeu Snake"></canvas>
+                                            </div>
+                                        </div>
+                                    </div>
+                                </div>
+
+                                <div class="col-12 col-lg-4">
+                                    <div class="card shadow-sm app-controls-card">
+                                        <div class="card-header d-flex align-items-center justify-content-between gap-2">
+                                            <span class="fw-semibold"><i class="fa-solid fa-keyboard me-2" aria-hidden="true"></i>Contrôles</span>
+                                            <span class="small text-body-secondary">clavier / tactile</span>
+                                        </div>
+                                        <div class="card-body">
+                                            <p class="small text-body-secondary">Utilisez les flèches, WASD, ZQSD ou les boutons directionnels.</p>
+                                            <div class="direction-pad mx-auto" aria-label="Contrôles directionnels tactiles">
+                                                <button class="btn btn-outline-primary direction-up" type="button" data-direction="up" aria-label="Haut">
+                                                    <i class="fa-solid fa-arrow-up" aria-hidden="true"></i>
+                                                </button>
+                                                <button class="btn btn-outline-primary direction-left" type="button" data-direction="left" aria-label="Gauche">
+                                                    <i class="fa-solid fa-arrow-left" aria-hidden="true"></i>
+                                                </button>
+                                                <button class="btn btn-outline-primary direction-down" type="button" data-direction="down" aria-label="Bas">
+                                                    <i class="fa-solid fa-arrow-down" aria-hidden="true"></i>
+                                                </button>
+                                                <button class="btn btn-outline-primary direction-right" type="button" data-direction="right" aria-label="Droite">
+                                                    <i class="fa-solid fa-arrow-right" aria-hidden="true"></i>
+                                                </button>
+                                            </div>
+                                            <dl class="runtime-details small border-top pt-3 mt-3 mb-0">
+                                                <div class="d-flex justify-content-between gap-3">
+                                                    <dt class="text-body-secondary fw-normal">Provenance</dt>
+                                                    <dd class="mb-2 text-end"><output id="runtime-provenance">web / browser / wasm / unknown / unknown</output></dd>
+                                                </div>
+                                                <div class="d-flex justify-content-between gap-3">
+                                                    <dt class="text-body-secondary fw-normal">Assets</dt>
+                                                    <dd class="mb-0 text-end"><output id="asset-status">chargement…</output></dd>
+                                                </div>
+                                            </dl>
+                                            <div class="alert alert-info small mt-3 mb-0" role="note">
+                                                Les entrées ne font pas avancer la simulation : elles sont consommées au prochain <code>tick()</code> WASM.
+                                            </div>
+                                        </div>
+                                    </div>
+                                </div>
+                            </div>
+
+                            <p id="startup-error" class="alert alert-danger mt-3 mb-0" role="alert" hidden></p>
+                        </div>
+                    </div>
+                    </div>
+                </section>
+            </div>
+        </main>
+
+        <footer class="app-footer bg-dark text-light">
+            <div class="container h-100 d-flex align-items-center justify-content-center">
+                <small>&copy; 2026 SASEDEV</small>
+            </div>
+        </footer>
+
+        <script type="module" src="ts/main.ts" defer></script>
+    </body>
+</html>

Web/game-snake-poc/frontend/sass/_app.scss

@@ -0,0 +1,165 @@
+// file: Web/game-snake-poc/frontend/sass/_app.scss
+// version: 4
+
+$app-header-height: 72px;
+$app-footer-height: 42px;
+
+html,
+body {
+    width: 100%;
+    min-width: 320px;
+    height: 100%;
+}
+
+body {
+    margin: 0;
+    overflow: hidden;
+    background: $gray-100;
+    overscroll-behavior: none;
+}
+
+.min-w-0 {
+    min-width: 0;
+}
+
+.app-header {
+    position: fixed;
+    inset: 0 0 auto;
+    height: $app-header-height;
+    z-index: 1020;
+    border-bottom: 2px solid rgba($primary, 0.3);
+}
+
+.app-footer {
+    position: fixed;
+    inset: auto 0 0;
+    height: $app-footer-height;
+    z-index: 1020;
+    border-top: 2px solid rgba($primary, 0.3);
+}
+
+.app-main {
+    position: relative;
+    width: 100%;
+    height: calc(100vh - $app-header-height - $app-footer-height);
+    margin-top: $app-header-height;
+    margin-bottom: $app-footer-height;
+    overflow: hidden;
+}
+
+.app-main > .row {
+    flex-wrap: nowrap;
+    min-width: 0;
+}
+
+.app-scrollable {
+    height: 100%;
+    max-height: 100%;
+}
+
+.app-content {
+    min-width: 0;
+    height: 100%;
+    max-height: 100%;
+}
+
+.app-logo {
+    width: 42px;
+    height: 42px;
+    font-size: 1.75rem;
+}
+
+.app-shell-card {
+    width: 100%;
+    max-width: 1180px;
+    min-width: 0;
+}
+
+.game-stage {
+    width: 100%;
+    max-width: 520px;
+    margin-inline: auto;
+    aspect-ratio: 3 / 5;
+    overflow: hidden;
+    background: $black;
+    border: 1px solid rgba($primary, 0.35);
+}
+
+#game {
+    display: block;
+    width: 100%;
+    height: 100%;
+    touch-action: none;
+    outline: none;
+}
+
+#game:focus-visible {
+    box-shadow: inset 0 0 0 3px rgba($primary, 0.85);
+}
+
+.app-controls-card {
+    min-width: 0;
+}
+
+.runtime-details dd {
+    min-width: 0;
+    overflow-wrap: anywhere;
+}
+
+.direction-pad {
+    display: grid;
+    grid-template-columns: repeat(3, minmax(64px, 88px));
+    grid-template-rows: repeat(2, minmax(56px, 72px));
+    gap: 0.5rem;
+    justify-content: center;
+    user-select: none;
+}
+
+.direction-pad .btn {
+    touch-action: manipulation;
+    font-size: 1.25rem;
+}
+
+.direction-up {
+    grid-column: 2;
+    grid-row: 1;
+}
+
+.direction-left {
+    grid-column: 1;
+    grid-row: 2;
+}
+
+.direction-down {
+    grid-column: 2;
+    grid-row: 2;
+}
+
+.direction-right {
+    grid-column: 3;
+    grid-row: 2;
+}
+
+@media (max-width: 575.98px) {
+    $mobile-header-height: 64px;
+
+    .app-header {
+        height: $mobile-header-height;
+    }
+
+    .app-main {
+        height: calc(100vh - $mobile-header-height - $app-footer-height);
+        margin-top: $mobile-header-height;
+    }
+
+    .app-logo {
+        width: 34px;
+        height: 34px;
+        font-size: 1.4rem;
+    }
+
+    .direction-pad {
+        width: 100%;
+        grid-template-columns: repeat(3, minmax(72px, 1fr));
+    }
+}

Web/game-snake-poc/frontend/sass/_bootswatch.scss

@@ -0,0 +1,160 @@
+// file: Web/game-snake-poc/frontend/sass/_bootswatch.scss
+// version: 1
+
+// Pulse 5.3.8
+// Bootswatch
+
+
+// Variables
+
+// Buttons
+
+.btn {
+
+    &:focus,
+    &:active,
+    &:active:focus,
+    &.active:focus {
+        outline: none;
+    }
+
+    &-secondary {
+        color: $gray-900;
+        background-color: $white;
+        border-color: #ccc;
+
+        &:hover {
+            color: $gray-900;
+            background-color: $gray-300;
+            border-color: $gray-500;
+        }
+
+        &.disabled {
+            color: tint-color($gray-900, 5%);
+            background-color: $white;
+            border-color: tint-color(#ccc, 5%);
+        }
+    }
+
+    &-warning {
+        color: $white;
+    }
+
+    &-primary:focus {
+        box-shadow: 0 0 5px tint-color($primary, 10%);
+    }
+
+    &-secondary:focus {
+        box-shadow: 0 0 5px $gray-400;
+    }
+
+    &-success:focus {
+        box-shadow: 0 0 5px tint-color($success, 10%);
+    }
+
+    &-info:focus {
+        box-shadow: 0 0 5px tint-color($info, 10%);
+    }
+
+    &-warning:focus {
+        box-shadow: 0 0 5px tint-color($warning, 10%);
+    }
+
+    &-danger:focus {
+        box-shadow: 0 0 5px tint-color($danger, 10%);
+    }
+
+    &.disabled:focus {
+        box-shadow: none;
+    }
+}
+
+// Tables
+
+.table .thead-dark th {
+    background-color: $secondary;
+    border-color: $table-border-color;
+}
+
+.table-primary,
+.table-secondary,
+.table-success,
+.table-warning,
+.table-danger,
+.table-info,
+.table-light {
+    --#{$prefix}table-color: #{$body-color};
+}
+
+// Forms
+
+.form-control:focus {
+    box-shadow: 0 0 5px rgba(100, 65, 164, .4);
+}
+
+// Navs
+
+.nav-tabs {
+
+    .nav-link,
+    .nav-link.active {
+        border-width: 0 0 1px;
+    }
+
+    .nav-link:hover,
+    .nav-link.active,
+    .nav-link.active:hover,
+    .nav-link.active:focus {
+        border-bottom: 1px solid $primary;
+    }
+
+    .nav-item+.nav-item {
+        margin-left: 0;
+    }
+}
+
+.breadcrumb {
+    &-item.active {
+        color: $gray-700;
+    }
+}
+
+// Indicators
+
+.badge {
+    &.bg-light {
+        color: $dark;
+    }
+}
+
+// Progress bars
+
+.progress {
+    height: 8px;
+}
+
+// Containers
+
+.list-group {
+    &-item {
+        color: rgba(255, 255, 255, .8);
+
+        &.active,
+        &:hover,
+        &:focus {
+            color: $white;
+        }
+
+        &.active {
+            font-weight: 700;
+
+            &:hover {
+                background-color: $list-group-hover-bg;
+            }
+        }
+
+        &.disabled:hover {
+            color: $list-group-disabled-color;
+        }
+    }
+}

Web/game-snake-poc/frontend/sass/_fontawesome.scss

@@ -0,0 +1,19 @@
+// file: Web/game-snake-poc/frontend/sass/_fontawesome.scss
+// version: 1
+
+//@use '@fortawesome/fontawesome-free/scss/variables' with (
+//    // customizing $font-path - make sure it points to where your webfonts are stored in your project
+//  $font-path: '../webfonts',
+//);
+@use '@fortawesome/fontawesome-free/scss/variables' with (
+    // use fonts from @fortawesome/fontawesome-free
+  $font-path: '@fortawesome/fontawesome-free/webfonts',
+);
+// load Font Awesome core
+@use '@fortawesome/fontawesome-free/scss/fontawesome';
+
+// load and make available Font Awesome helpers (mixins, functions, and variables)
+@use '@fortawesome/fontawesome-free/scss/fa' as fa;
+@use '@fortawesome/fontawesome-free/scss/brands' as fa-brands;
+@use '@fortawesome/fontawesome-free/scss/regular' as fa-regular;
+@use '@fortawesome/fontawesome-free/scss/solid' as fa-solid;

Web/game-snake-poc/frontend/sass/_simplebar.scss

@@ -0,0 +1,248 @@
+// file: Web/game-snake-poc/frontend/sass/_simplebar.scss
+// version: 1
+
+/* Rtl support */
+[data-simplebar] {
+    position: relative;
+    flex-direction: column;
+    flex-wrap: wrap;
+    justify-content: flex-start;
+    align-content: flex-start;
+    align-items: flex-start;
+}
+
+.simplebar-wrapper {
+    overflow: hidden;
+    width: inherit;
+    height: inherit;
+    max-width: inherit;
+    max-height: inherit;
+}
+
+.simplebar-mask {
+    direction: inherit;
+    position: absolute;
+    overflow: hidden;
+    padding: 0;
+    margin: 0;
+    left: 0;
+    top: 0;
+    bottom: 0;
+    right: 0;
+    width: auto !important;
+    height: auto !important;
+//    z-index: 0;
+    inset: 0;
+}
+
+.simplebar-offset {
+    direction: inherit !important;
+    box-sizing: inherit !important;
+    resize: none !important;
+    position: absolute;
+    top: 0;
+    left: 0;
+    bottom: 0;
+    right: 0;
+    padding: 0;
+    margin: 0;
+    -webkit-overflow-scrolling: touch;
+    inset: 0;
+}
+
+.simplebar-content-wrapper {
+    direction: inherit;
+    box-sizing: border-box !important;
+    position: relative;
+    display: block;
+    height: 100%;
+    width: auto;
+    max-width: 100%;
+    max-height: 100%;
+    overflow: auto;
+    scrollbar-width: none;
+    -ms-overflow-style: none;
+
+    &::-webkit-scrollbar {
+        display: none;
+        width: 0;
+        height: 0;
+    }
+}
+
+.simplebar-hide-scrollbar {
+    &::-webkit-scrollbar {
+        display: none;
+        width: 0;
+        height: 0;
+    }
+
+    position: fixed;
+    left: 0;
+    visibility: hidden;
+    overflow-y: scroll;
+    scrollbar-width: none;
+    -ms-overflow-style: none;
+}
+
+.simplebar-content {
+    &:before {
+        content: ' ';
+        display: table;
+    }
+
+    &:after {
+        content: ' ';
+        display: table;
+    }
+}
+
+.simplebar-placeholder {
+    max-height: 100%;
+    max-width: 100%;
+    width: 100%;
+    pointer-events: none;
+}
+
+.simplebar-height-auto-observer-wrapper {
+    box-sizing: inherit !important;
+    height: 100%;
+    width: 100%;
+    max-width: 1px;
+    position: relative;
+    float: left;
+    max-height: 1px;
+    overflow: hidden;
+//    z-index: -1;
+    padding: 0;
+    margin: 0;
+    pointer-events: none;
+    flex-grow: inherit;
+    flex-shrink: 0;
+    flex-basis: 0;
+}
+
+.simplebar-height-auto-observer {
+    box-sizing: inherit;
+    display: block;
+    opacity: 0;
+    position: absolute;
+    top: 0;
+    left: 0;
+    height: 1000%;
+    width: 1000%;
+    min-height: 1px;
+    min-width: 1px;
+    overflow: hidden;
+    pointer-events: none;
+//    z-index: -1;
+}
+
+.simplebar-track {
+//    z-index: 1;
+    position: absolute;
+    right: 0;
+    bottom: 0;
+    pointer-events: none;
+    overflow: hidden;
+}
+
+[data-simplebar].simplebar-dragging {
+    pointer-events: none;
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+
+    .simplebar-content {
+        pointer-events: none;
+        -webkit-touch-callout: none;
+        -webkit-user-select: none;
+        -moz-user-select: none;
+        -ms-user-select: none;
+        user-select: none;
+    }
+
+    .simplebar-track {
+        pointer-events: all;
+    }
+}
+
+.simplebar-scrollbar {
+    position: absolute;
+    left: 0;
+    right: 0;
+    min-height: 10px;
+    
+
+    &:before {
+        position: absolute;
+        content: '';
+        background: black;
+        border-radius: 7px;
+        left: 2px;
+        right: 2px;
+        opacity: 0;
+        transition: opacity 0.2s 0.5s linear;
+        top: 2px;
+        bottom: 2px;
+    }
+}
+
+.simplebar-scrollbar.simplebar-visible {
+    &:before {
+        opacity: 0.5;
+        transition-delay: 0s;
+        transition-duration: 0s;
+    }
+}
+
+.simplebar-track.simplebar-vertical {
+    top: 0;
+    width: 11px;
+}
+
+.simplebar-track.simplebar-horizontal {
+    left: 0;
+    height: 11px;
+
+    .simplebar-scrollbar {
+        right: auto;
+        left: 0;
+        top: 0;
+        bottom: 0;
+        min-height: 0;
+        min-width: 10px;
+        width: auto;
+    }
+}
+
+[data-simplebar-direction='rtl'] {
+    .simplebar-track.simplebar-vertical {
+        right: auto;
+        left: 0;
+    }
+}
+
+.simplebar-dummy-scrollbar-size {
+    direction: rtl;
+    position: fixed;
+    opacity: 0;
+    visibility: hidden;
+    height: 500px;
+    width: 500px;
+    overflow-y: hidden;
+    overflow-x: scroll;
+    -ms-overflow-style: scrollbar !important;
+
+    >div {
+        width: 200%;
+        height: 200%;
+        margin: 10px 0;
+    }
+}
+
+.simplebar-hover {
+    cursor: pointer;
+}

Web/game-snake-poc/frontend/sass/_variables.scss

@@ -0,0 +1,95 @@
+// file: Web/game-snake-poc/frontend/sass/_variables.scss
+// version: 1
+
+// Pulse 5.3.8
+// Bootswatch
+
+$theme: "pulse" !default;
+
+//
+// Color system
+//
+
+$white:    #fff !default;
+$gray-100: #fafafa !default;
+$gray-200: #f9f8fc !default;
+$gray-300: #ededed !default;
+$gray-400: #cbc8d0 !default;
+$gray-500: #adb5bd !default;
+$gray-600: #868e96 !default;
+$gray-700: #444 !default;
+$gray-800: #343a40 !default;
+$gray-900: #17141f !default;
+$black:    #000 !default;
+
+$blue:    #007bff !default;
+$indigo:  #6610f2 !default;
+$purple:  #593196 !default;
+$pink:    #e83e8c !default;
+$red:     #fc3939 !default;
+$orange:  #fd7e14 !default;
+$yellow:  #efa31d !default;
+$green:   #13b955 !default;
+$teal:    #20c997 !default;
+$cyan:    #009cdc !default;
+
+$primary:       $purple !default;
+$secondary:     #a991d4 !default;
+$success:       $green !default;
+$info:          $cyan !default;
+$warning:       $yellow !default;
+$danger:        $red !default;
+$light:         $gray-200 !default;
+$dark:          $gray-900 !default;
+
+$min-contrast-ratio:   2.1 !default;
+
+// Options
+
+$enable-rounded: false !default;
+
+// Body
+
+$body-color:                $gray-700 !default;
+
+// Links
+
+$link-hover-color:          $primary !default;
+
+// Tables
+
+$table-color:                 initial !default;
+
+$table-border-color:          rgba(0, 0, 0, .05) !default;
+
+// Forms
+
+$input-focus-border-color:              $primary !default;
+
+// Dropdowns
+
+$dropdown-link-hover-color:         $white !default;
+$dropdown-link-hover-bg:            $primary !default;
+
+// Navs
+
+$nav-tabs-border-color:             $gray-300 !default;
+$nav-tabs-link-hover-border-color:  $primary !default;
+
+// Navbar
+
+$navbar-padding-y:                  1.2rem !default;
+
+// Progress bars
+
+$progress-bg:                       $gray-300 !default;
+$progress-bar-bg:                   $primary !default;
+
+// List group
+
+$list-group-bg:                     $gray-900 !default;
+$list-group-border-color:           transparent !default;
+$list-group-hover-bg:               lighten($list-group-bg, 10%) !default;
+$list-group-active-color:           $white !default;
+$list-group-active-bg:              $list-group-bg !default;
+$list-group-disabled-color:         lighten($list-group-bg, 30%) !default;

Web/game-snake-poc/frontend/sass/main.scss

@@ -0,0 +1,10 @@
+// file: Web/game-snake-poc/frontend/sass/main.scss
+// version: 2
+
+@import "bootstrap/scss/functions";
+@import "variables";
+@import "fontawesome";
+@import "simplebar";
+@import "bootstrap/scss/bootstrap";
+@import "bootswatch";
+@import "app";

Web/game-snake-poc/frontend/ts/assets.ts

@@ -0,0 +1,54 @@
+// file: Web/game-snake-poc/frontend/ts/assets.ts
+// version: 1
+
+export interface SnakeWebAssets {
+    engineGeneration: number;
+    game: string;
+    gameKind: string;
+}
+
+interface CommonRuntimeAsset {
+    schema: number;
+    scope: string;
+    engine_generation: number;
+}
+
+interface GameRuntimeAsset {
+    schema: number;
+    game: string;
+    kind: string;
+}
+
+async function fetchJson<T>(relativePath: string): Promise<T> {
+    const response = await fetch(new URL(relativePath, document.baseURI));
+    if (!response.ok) {
+        throw new Error(`Asset runtime indisponible (${response.status}) : ${relativePath}`);
+    }
+    return (await response.json()) as T;
+}
+
+function validateCommonRuntime(asset: CommonRuntimeAsset): void {
+    if (asset.schema !== 1 || asset.scope !== "common" || asset.engine_generation !== 1) {
+        throw new Error("Asset common://data/runtime.json invalide pour le POC Web Snake.");
+    }
+}
+
+function validateGameRuntime(asset: GameRuntimeAsset): void {
+    if (asset.schema !== 1 || asset.game !== "game-snake-poc" || asset.kind !== "snake") {
+        throw new Error("Asset game://data/game.json invalide pour le POC Web Snake.");
+    }
+}
+
+export async function loadSnakeWebAssets(): Promise<SnakeWebAssets> {
+    const [commonRuntime, gameRuntime] = await Promise.all([
+        fetchJson<CommonRuntimeAsset>("./common/data/runtime.json"),
+        fetchJson<GameRuntimeAsset>("./game/data/game.json"),
+    ]);
+    validateCommonRuntime(commonRuntime);
+    validateGameRuntime(gameRuntime);
+    return {
+        engineGeneration: commonRuntime.engine_generation,
+        game: gameRuntime.game,
+        gameKind: gameRuntime.kind,
+    };
+}

Web/game-snake-poc/frontend/ts/game.ts

@@ -0,0 +1,179 @@
+// file: Web/game-snake-poc/frontend/ts/game.ts
+// version: 3
+
+import init, { SnakeWasmGame } from "@snake-wasm";
+import { webDebug, webInfo } from "./logging";
+import { BrowserRuntimeProvenance, type SnakeInputSource } from "./provenance";
+
+const FRAME_MILLIS = 16;
+const MAX_FRAME_ELAPSED_MILLIS = 250;
+
+export type SnakeDirection = "left" | "right" | "up" | "down";
+
+export interface SnakeWebSession {
+    queueDirection(direction: SnakeDirection, source: SnakeInputSource): void;
+    pause(): void;
+    resume(): void;
+    renderNow(): void;
+    refreshDeviceClass(): void;
+    dispose(): void;
+}
+
+function color(red: number, green: number, blue: number): string {
+    return `rgb(${red} ${green} ${blue})`;
+}
+
+function resizeCanvas(canvas: HTMLCanvasElement): void {
+    const ratio = window.devicePixelRatio || 1;
+    const width = Math.max(1, Math.floor(canvas.clientWidth * ratio));
+    const height = Math.max(1, Math.floor(canvas.clientHeight * ratio));
+    if (canvas.width !== width || canvas.height !== height) {
+        canvas.width = width;
+        canvas.height = height;
+    }
+}
+
+function render(
+    game: SnakeWasmGame,
+    canvas: HTMLCanvasElement,
+    context: CanvasRenderingContext2D,
+    score: HTMLOutputElement,
+    length: HTMLOutputElement,
+): void {
+    resizeCanvas(canvas);
+    context.fillStyle = color(game.background_red(), game.background_green(), game.background_blue());
+    context.fillRect(0, 0, canvas.width, canvas.height);
+    const count = game.rectangle_count();
+    for (let index = 0; index < count; index += 1) {
+        context.fillStyle = color(game.rectangle_red(index), game.rectangle_green(index), game.rectangle_blue(index));
+        context.fillRect(
+            game.rectangle_x(index) * canvas.width,
+            game.rectangle_y(index) * canvas.height,
+            game.rectangle_width(index) * canvas.width,
+            game.rectangle_height(index) * canvas.height,
+        );
+    }
+    score.value = `Score : ${game.score()}`;
+    length.value = `Longueur : ${game.length()}`;
+}
+
+function queueDirection(game: SnakeWasmGame, direction: SnakeDirection): void {
+    switch (direction) {
+        case "left":
+            game.left();
+            return;
+        case "right":
+            game.right();
+            return;
+        case "up":
+            game.up();
+            return;
+        case "down":
+            game.down();
+            return;
+    }
+}
+
+export async function startGame(
+    canvas: HTMLCanvasElement,
+    score: HTMLOutputElement,
+    length: HTMLOutputElement,
+    provenanceOutput: HTMLOutputElement,
+): Promise<SnakeWebSession> {
+    await init();
+    webInfo("snake-web-runtime", "wasm_initialized");
+    const context = canvas.getContext("2d");
+    if (context === null) {
+        throw new Error("Le contexte Canvas 2D est indisponible.");
+    }
+    const renderingContext: CanvasRenderingContext2D = context;
+    const game = new SnakeWasmGame();
+    const provenance = new BrowserRuntimeProvenance(game, provenanceOutput);
+    let previous = performance.now();
+    let accumulator = 0;
+    let animationFrame: number | null = null;
+    let running = false;
+    let disposed = false;
+
+    function renderNow(): void {
+        if (disposed) {
+            return;
+        }
+        render(game, canvas, renderingContext, score, length);
+    }
+
+    function schedule(): void {
+        if (!running || disposed || animationFrame !== null) {
+            return;
+        }
+        animationFrame = window.requestAnimationFrame(frame);
+    }
+
+    function frame(now: number): void {
+        animationFrame = null;
+        if (!running || disposed) {
+            return;
+        }
+        const elapsed = Math.min(Math.max(0, now - previous), MAX_FRAME_ELAPSED_MILLIS);
+        previous = now;
+        accumulator += elapsed;
+        while (accumulator >= FRAME_MILLIS) {
+            game.tick();
+            accumulator -= FRAME_MILLIS;
+        }
+        renderNow();
+        schedule();
+    }
+
+    function pause(): void {
+        if (!running || disposed) {
+            return;
+        }
+        running = false;
+        accumulator = 0;
+        if (animationFrame !== null) {
+            window.cancelAnimationFrame(animationFrame);
+            animationFrame = null;
+        }
+        webDebug("snake-web-runtime", "runtime_paused");
+    }
+
+    function resume(): void {
+        if (running || disposed) {
+            return;
+        }
+        previous = performance.now();
+        accumulator = 0;
+        running = true;
+        schedule();
+        webDebug("snake-web-runtime", "runtime_resumed");
+    }
+
+    renderNow();
+    resume();
+    return {
+        queueDirection(direction: SnakeDirection, source: SnakeInputSource): void {
+            if (disposed) {
+                return;
+            }
+            provenance.recordInput(source);
+            queueDirection(game, direction);
+        },
+        pause,
+        resume,
+        renderNow,
+        refreshDeviceClass(): void {
+            if (!disposed) {
+                provenance.refreshDeviceClass();
+            }
+        },
+        dispose(): void {
+            if (disposed) {
+                return;
+            }
+            pause();
+            disposed = true;
+            game.free();
+        },
+    };
+}

Web/game-snake-poc/frontend/ts/input.ts

@@ -0,0 +1,61 @@
+// file: Web/game-snake-poc/frontend/ts/input.ts
+// version: 2
+
+import type { SnakeDirection, SnakeWebSession } from "./game";
+import { webDebug } from "./logging";
+
+const KEY_DIRECTIONS: Readonly<Record<string, SnakeDirection>> = {
+    arrowleft: "left",
+    a: "left",
+    q: "left",
+    arrowright: "right",
+    d: "right",
+    arrowup: "up",
+    w: "up",
+    z: "up",
+    arrowdown: "down",
+    s: "down",
+};
+
+function buttonDirection(button: HTMLButtonElement): SnakeDirection | null {
+    const direction = button.dataset.direction;
+    if (direction === "left" || direction === "right" || direction === "up" || direction === "down") {
+        return direction;
+    }
+    return null;
+}
+
+export function bindInputs(session: SnakeWebSession, buttons: readonly HTMLButtonElement[]): void {
+    window.addEventListener("keydown", event => {
+        if (event.repeat) {
+            return;
+        }
+        const direction = KEY_DIRECTIONS[event.key.toLowerCase()];
+        if (direction === undefined) {
+            return;
+        }
+        event.preventDefault();
+        session.queueDirection(direction, "keyboard-mouse");
+        webDebug("snake-web-input", "direction", { direction, source: "keyboard-mouse" });
+    });
+
+    for (const button of buttons) {
+        const direction = buttonDirection(button);
+        if (direction === null) {
+            continue;
+        }
+        button.addEventListener("pointerdown", event => {
+            event.preventDefault();
+            const source = event.pointerType === "touch" ? "touch" : "keyboard-mouse";
+            session.queueDirection(direction, source);
+            webDebug("snake-web-input", "direction", { direction, source });
+        });
+        button.addEventListener("click", event => {
+            if (event.detail !== 0) {
+                return;
+            }
+            session.queueDirection(direction, "keyboard-mouse");
+            webDebug("snake-web-input", "direction", { direction, source: "keyboard-mouse" });
+        });
+    }
+}

Web/game-snake-poc/frontend/ts/lifecycle.ts

@@ -0,0 +1,58 @@
+// file: Web/game-snake-poc/frontend/ts/lifecycle.ts
+// version: 1
+
+import type { SnakeWebSession } from "./game";
+import { webDebug, webInfo } from "./logging";
+
+export interface SnakeLifecycleBinding {
+    dispose(): void;
+}
+
+export function bindBrowserLifecycle(session: SnakeWebSession, stage: HTMLElement): SnakeLifecycleBinding {
+    const resizeObserver = new ResizeObserver(() => {
+        session.refreshDeviceClass();
+        session.renderNow();
+    });
+
+    function synchronizeVisibility(): void {
+        if (document.visibilityState === "hidden") {
+            session.pause();
+            webDebug("snake-web-lifecycle", "visibility_hidden");
+            return;
+        }
+        session.resume();
+        session.renderNow();
+        webDebug("snake-web-lifecycle", "visibility_visible");
+    }
+
+    function pageHide(event: PageTransitionEvent): void {
+        if (event.persisted) {
+            session.pause();
+        } else {
+            session.dispose();
+        }
+        webInfo("snake-web-lifecycle", "page_hide", { persisted: event.persisted });
+    }
+
+    function pageShow(event: PageTransitionEvent): void {
+        session.resume();
+        session.renderNow();
+        webInfo("snake-web-lifecycle", "page_show", { persisted: event.persisted });
+    }
+
+    resizeObserver.observe(stage);
+    document.addEventListener("visibilitychange", synchronizeVisibility);
+    window.addEventListener("pagehide", pageHide);
+    window.addEventListener("pageshow", pageShow);
+    synchronizeVisibility();
+
+    return {
+        dispose(): void {
+            resizeObserver.disconnect();
+            document.removeEventListener("visibilitychange", synchronizeVisibility);
+            window.removeEventListener("pagehide", pageHide);
+            window.removeEventListener("pageshow", pageShow);
+            session.dispose();
+        },
+    };
+}

Web/game-snake-poc/frontend/ts/logging.ts

@@ -0,0 +1,45 @@
+// file: Web/game-snake-poc/frontend/ts/logging.ts
+// version: 1
+
+export type WebLogLevel = "debug" | "info" | "warn" | "error";
+export type WebLogFields = Readonly<Record<string, boolean | number | string | null>>;
+
+type ConsoleMethod = (...items: unknown[]) => void;
+
+function consoleMethod(level: WebLogLevel): ConsoleMethod {
+    if (level === "debug") {
+        return console.debug.bind(console);
+    }
+    if (level === "info") {
+        return console.info.bind(console);
+    }
+    if (level === "warn") {
+        return console.warn.bind(console);
+    }
+    return console.error.bind(console);
+}
+
+function emit(level: WebLogLevel, target: string, action: string, fields: WebLogFields = {}): void {
+    const event = {
+        target,
+        action,
+        ...fields,
+    };
+    consoleMethod(level)(`[games.sasedev][${target}] ${action}`, event);
+}
+
+export function webDebug(target: string, action: string, fields: WebLogFields = {}): void {
+    emit("debug", target, action, fields);
+}
+
+export function webInfo(target: string, action: string, fields: WebLogFields = {}): void {
+    emit("info", target, action, fields);
+}
+
+export function webWarn(target: string, action: string, fields: WebLogFields = {}): void {
+    emit("warn", target, action, fields);
+}
+
+export function webError(target: string, action: string, fields: WebLogFields = {}): void {
+    emit("error", target, action, fields);
+}

Web/game-snake-poc/frontend/ts/main.ts

@@ -0,0 +1,66 @@
+// file: Web/game-snake-poc/frontend/ts/main.ts
+// version: 3
+
+import ResizeObserver from "resize-observer-polyfill";
+import "simplebar";
+import { loadSnakeWebAssets } from "./assets";
+import { startGame } from "./game";
+import { bindInputs } from "./input";
+import { bindBrowserLifecycle } from "./lifecycle";
+import { webError, webInfo } from "./logging";
+
+(window as Window & typeof globalThis & { ResizeObserver?: typeof ResizeObserver }).ResizeObserver = ResizeObserver;
+
+function requireElement<T extends Element>(selector: string): T {
+    const element = document.querySelector<T>(selector);
+    if (element === null) {
+        throw new Error(`Élément frontend requis absent : ${selector}`);
+    }
+    return element;
+}
+
+async function main(): Promise<void> {
+    const canvas = requireElement<HTMLCanvasElement>("#game");
+    const stage = requireElement<HTMLElement>(".game-stage");
+    const score = requireElement<HTMLOutputElement>("#score");
+    const length = requireElement<HTMLOutputElement>("#length");
+    const provenance = requireElement<HTMLOutputElement>("#runtime-provenance");
+    const assets = requireElement<HTMLOutputElement>("#asset-status");
+    const status = requireElement<HTMLSpanElement>("#runtime-status");
+    const error = requireElement<HTMLParagraphElement>("#startup-error");
+    const buttons = Array.from(document.querySelectorAll<HTMLButtonElement>("[data-direction]"));
+
+    status.textContent = "Chargement assets…";
+    const assetMetadata = await loadSnakeWebAssets();
+    assets.value = `${assetMetadata.gameKind} / engine-v${assetMetadata.engineGeneration}`;
+    webInfo("snake-web-assets", "runtime_assets_loaded", {
+        engineGeneration: assetMetadata.engineGeneration,
+        game: assetMetadata.game,
+        gameKind: assetMetadata.gameKind,
+    });
+
+    status.textContent = "Chargement WASM…";
+    const session = await startGame(canvas, score, length, provenance);
+    bindInputs(session, buttons);
+    bindBrowserLifecycle(session, stage);
+    status.className = "badge text-bg-success";
+    status.textContent = "Prêt";
+    error.hidden = true;
+    canvas.focus();
+    webInfo("snake-web-main", "runtime_ready");
+}
+
+void main().catch(caughtError => {
+    const status = document.querySelector<HTMLSpanElement>("#runtime-status");
+    const error = document.querySelector<HTMLParagraphElement>("#startup-error");
+    const message = caughtError instanceof Error ? caughtError.stack ?? caughtError.message : String(caughtError);
+    if (status !== null) {
+        status.className = "badge text-bg-danger";
+        status.textContent = "Erreur";
+    }
+    if (error !== null) {
+        error.textContent = `Impossible de démarrer Snake : ${message}`;
+        error.hidden = false;
+    }
+    webError("snake-web-main", "runtime_start_failed", { message });
+});

Web/game-snake-poc/frontend/ts/provenance.ts

@@ -0,0 +1,98 @@
+// file: Web/game-snake-poc/frontend/ts/provenance.ts
+// version: 2
+
+import type { SnakeWasmGame } from "@snake-wasm";
+import { webInfo } from "./logging";
+
+export type SnakeInputSource = "keyboard-mouse" | "touch";
+
+type DeviceClass = "desktop" | "phone" | "tablet" | "unknown";
+type InputProfile = "keyboard-mouse" | "mixed" | "touch" | "unknown";
+
+function detectedDeviceClass(): DeviceClass {
+    const coarsePointer = window.matchMedia("(pointer: coarse)").matches;
+    const finePointer = window.matchMedia("(pointer: fine)").matches;
+    if (!coarsePointer || finePointer) {
+        return "desktop";
+    }
+    const shortEdge = Math.min(window.screen.width, window.screen.height);
+    if (!Number.isFinite(shortEdge) || shortEdge <= 0) {
+        return "unknown";
+    }
+    return shortEdge < 768 ? "phone" : "tablet";
+}
+
+function inputProfile(keyboardMouseObserved: boolean, touchObserved: boolean): InputProfile {
+    if (keyboardMouseObserved && touchObserved) {
+        return "mixed";
+    }
+    if (keyboardMouseObserved) {
+        return "keyboard-mouse";
+    }
+    if (touchObserved) {
+        return "touch";
+    }
+    return "unknown";
+}
+
+function displayLabel(game: SnakeWasmGame): string {
+    return [
+        game.provenance_platform_family(),
+        game.provenance_runtime_host(),
+        game.provenance_execution_model(),
+        game.provenance_device_class(),
+        game.provenance_input_profile(),
+    ].join(" / ");
+}
+
+export class BrowserRuntimeProvenance {
+    private keyboardMouseObserved = false;
+    private touchObserved = false;
+    private deviceClass: DeviceClass = detectedDeviceClass();
+
+    public constructor(
+        private readonly game: SnakeWasmGame,
+        private readonly output: HTMLOutputElement,
+    ) {
+        this.synchronize();
+    }
+
+    public recordInput(source: SnakeInputSource): void {
+        if (source === "touch") {
+            if (this.touchObserved) {
+                return;
+            }
+            this.touchObserved = true;
+        } else {
+            if (this.keyboardMouseObserved) {
+                return;
+            }
+            this.keyboardMouseObserved = true;
+        }
+        this.synchronize();
+    }
+
+    public refreshDeviceClass(): void {
+        const nextDeviceClass = detectedDeviceClass();
+        if (nextDeviceClass === this.deviceClass) {
+            return;
+        }
+        this.deviceClass = nextDeviceClass;
+        this.synchronize();
+    }
+
+    private synchronize(): void {
+        const profile = inputProfile(this.keyboardMouseObserved, this.touchObserved);
+        if (!this.game.configure_runtime_provenance("web", "browser", this.deviceClass, profile)) {
+            throw new Error("La provenance navigateur n'a pas pu être configurée dans le bridge WASM.");
+        }
+        this.output.value = displayLabel(this.game);
+        webInfo("snake-web-provenance", "runtime_provenance", {
+            deviceClass: this.game.provenance_device_class(),
+            executionModel: this.game.provenance_execution_model(),
+            inputProfile: this.game.provenance_input_profile(),
+            platformFamily: this.game.provenance_platform_family(),
+            runtimeHost: this.game.provenance_runtime_host(),
+        });
+    }
+}

Web/game-snake-poc/package.json

@@ -0,0 +1,25 @@
+{
+    "name": "game-snake-poc-web",
+    "private": true,
+    "version": "0.3.0",
+    "type": "module",
+    "scripts": {
+        "dev": "vite",
+        "build": "tsc && vite build",
+        "preview": "vite preview"
+    },
+    "dependencies": {
+        "@fortawesome/fontawesome-free": "^7.3",
+        "bootstrap": "^5.3",
+        "resize-observer-polyfill": "^1.5",
+        "simplebar": "^6.3"
+    },
+    "devDependencies": {
+        "@types/bootstrap": "^5.2",
+        "@types/node": "^26.1",
+        "sass-embedded": "^1.102",
+        "typescript": "^7.0",
+        "vite": "^8.2",
+        "vite-plugin-static-copy": "^4.1"
+    }
+}

Web/game-snake-poc/tsconfig.json

@@ -0,0 +1,36 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "useDefineForClassFields": true,
+        "module": "ESNext",
+        "lib": [
+            "ES2022",
+            "DOM",
+            "DOM.Iterable"
+        ],
+        "skipLibCheck": true,
+        "moduleResolution": "bundler",
+        "allowImportingTsExtensions": true,
+        "resolveJsonModule": true,
+        "isolatedModules": true,
+        "noEmit": true,
+        "strict": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noFallthroughCasesInSwitch": true,
+        "allowSyntheticDefaultImports": true,
+        "types": [
+            "vite/client",
+            "node"
+        ],
+        "paths": {
+            "@snake-wasm": [
+                "../../../builds/sasedev-games/game-snake-poc-web/wasm/game_snake_poc_wasm.d.ts"
+            ]
+        }
+    },
+    "include": [
+        "frontend",
+        "vite.config.ts"
+    ]
+}

Web/game-snake-poc/vite.config.ts

@@ -0,0 +1,96 @@
+// file: Web/game-snake-poc/vite.config.ts
+// version: 3
+
+import { NodePackageImporter } from "sass-embedded";
+import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
+import { defineConfig, normalizePath } from "vite";
+import { viteStaticCopy } from "vite-plugin-static-copy";
+
+const appRoot = fileURLToPath(new URL(".", import.meta.url));
+const repositoryRoot = normalizePath(resolve(appRoot, "../.."));
+const frontendRoot = normalizePath(resolve(appRoot, "frontend"));
+const externalBuildRoot = normalizePath(resolve(repositoryRoot, "../builds/sasedev-games/game-snake-poc-web"));
+const wasmRoot = normalizePath(resolve(externalBuildRoot, "wasm"));
+const wasmModule = normalizePath(resolve(wasmRoot, "game_snake_poc_wasm.js"));
+const frontendDist = normalizePath(resolve(externalBuildRoot, "dist"));
+const viteCacheDir = normalizePath(resolve(externalBuildRoot, "vite-cache"));
+const commonRuntimeAsset = normalizePath(resolve(repositoryRoot, "assets/common/data/runtime.json"));
+const gameRuntimeAsset = normalizePath(resolve(repositoryRoot, "assets/game-snake-poc/data/game.json"));
+
+export default defineConfig({
+    plugins: [
+        viteStaticCopy({
+            targets: [
+                { src: commonRuntimeAsset, dest: "common/data", rename: { stripBase: true } },
+                { src: gameRuntimeAsset, dest: "game/data", rename: { stripBase: true } },
+            ],
+        }),
+    ],
+    base: "./",
+    cacheDir: viteCacheDir,
+    clearScreen: false,
+    root: frontendRoot,
+    publicDir: false,
+    input: {
+        main: normalizePath(resolve(frontendRoot, "main.html")),
+    },
+    resolve: {
+        alias: {
+            "@snake-wasm": wasmModule,
+        },
+    },
+    build: {
+        outDir: frontendDist,
+        emptyOutDir: true,
+        minify: true,
+        sourcemap: false,
+        cssCodeSplit: true,
+        rolldownOptions: {
+            output: {
+                entryFileNames: "js/[name]-[hash].js",
+                chunkFileNames: "js/chunks/[name]-[hash].js",
+                assetFileNames: assetInfo => {
+                    const originalName = assetInfo.names[0] ?? "";
+                    const extension = originalName.substring(originalName.lastIndexOf(".") + 1).toLowerCase();
+                    if (extension === "css") {
+                        return "css/[name]-[hash][extname]";
+                    }
+                    if (["eot", "otf", "ttf", "woff", "woff2"].includes(extension)) {
+                        return "fonts/[name]-[hash][extname]";
+                    }
+                    if (["png", "jpg", "jpeg", "gif", "svg", "webp", "ico"].includes(extension)) {
+                        return "imgs/[name][extname]";
+                    }
+                    if (extension === "wasm") {
+                        return "wasm/[name]-[hash][extname]";
+                    }
+                    return "otherassets/[name][extname]";
+                },
+            },
+        },
+    },
+    css: {
+        preprocessorOptions: {
+            scss: {
+                quietDeps: true,
+                silenceDeprecations: ["import", "color-functions", "global-builtin"],
+                verbose: false,
+                importers: [new NodePackageImporter()],
+            },
+        },
+    },
+    server: {
+        host: "127.0.0.1",
+        port: 1434,
+        strictPort: true,
+        fs: {
+            allow: [appRoot, repositoryRoot, externalBuildRoot],
+        },
+    },
+    preview: {
+        host: "127.0.0.1",
+        port: 4174,
+        strictPort: true,
+    },
+});

crates/apps/game-reflex-poc-tauri/tauri.conf.json

@@ -1,7 +1,6 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Reflex POC Tauri",
-  "version": "0.1.0",
   "identifier": "com.sasedev.games.reflex.tauri",
   "build": {
     "beforeDevCommand": {
@@ -31,6 +30,8 @@
   },
   "bundle": {
     "active": false,
-    "icon": ["icons/icon.png"]
+    "icon": [
+      "icons/icon.png"
+    ]
   }
 }

crates/apps/game-snake-poc-tauri/Cargo.toml

@@ -0,0 +1,34 @@
+# file: crates/apps/game-snake-poc-tauri/Cargo.toml
+# version: 1
+
+[package]
+name = "game-snake-poc-tauri"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+authors.workspace = true
+publish.workspace = true
+
+[lib]
+name = "game_snake_poc_tauri_lib"
+path = "src/lib.rs"
+crate-type = ["staticlib", "cdylib", "rlib"]
+
+[[bin]]
+name = "game-snake-poc-tauri"
+path = "src/main.rs"
+
+[build-dependencies]
+tauri-build.workspace = true
+
+[dependencies]
+engine-v1-platform-api = { path = "../../engines/engine-v1-platform-api" }
+game-logging-lib = { path = "../../common/game-logging-lib" }
+serde.workspace = true
+tauri.workspace = true
+tauri-plugin-tracing.workspace = true
+tracing.workspace = true
+
+[lints]
+workspace = true

crates/apps/game-snake-poc-tauri/README.md

@@ -0,0 +1,27 @@
+<!-- file: crates/apps/game-snake-poc-tauri/README.md -->
+<!-- version: 3 -->
+
+# game-snake-poc-tauri
+
+Host Tauri Android du POC Snake. Cette application réutilise le gameplay Rust de `game-snake-poc` et l'unique adapter WebAssembly `game-snake-poc-wasm` ; elle ne possède aucune règle de jeu.
+
+## Responsabilités
+
+La crate possède uniquement la frontière Tauri : initialisation du logging Rust, assemblage/plugins/commandes Tauri, contrat minimal de provenance native et frontend Vite/TypeScript exécuté dans la WebView Android.
+
+L'organisation Rust suit le modèle des applications Desk KSP :
+
+- `src/lib.rs` reste une façade et réexporte les éléments partagés au crate-root ;
+- `src/tauri.rs` assemble Tauri et fait déléguer les commandes aux modules propriétaires ;
+- `src/runtime.rs` possède le petit contrat runtime/provenance ;
+- `frontend/` contient le host WebView et consomme les bindings générés de `game-snake-poc-wasm`.
+
+Le frontend minimal de `0.3.1-0-pre.2` valide uniquement le démarrage Tauri, le bridge Rust, le tracing et le chargement du même adapter WASM que le Web direct. Canvas, contrôles, assets et lifecycle complet sont prévus dans les tranches suivantes.
+
+## Build
+
+Les hooks `beforeDevCommand` et `beforeBuildCommand` de Tauri possèdent le build WASM et Vite. Aucun orchestrateur Python n'est utilisé. Les bindings WASM, la distribution Vite, les caches, `node_modules/` et le projet Android généré restent hors des sources livrées ou dans des chemins générés ignorés.
+
+Le host ne modifie pas le projet Android généré par Tauri. La branche stable Tauri 2.11.x conserve son propre wrapper Gradle ; les commandes Android doivent donc s'exécuter avec un JDK compatible avec cette chaîne. Pour la machine de validation, `JAVA_HOME` doit pointer vers le JBR fourni par Android Studio (ou vers un autre JDK compatible), plutôt que vers le Java 25 global.
+
+Voir [`USAGE.md`](USAGE.md) pour l'initialisation locale et les smokes Android.

crates/apps/game-snake-poc-tauri/USAGE.md

@@ -0,0 +1,51 @@
+<!-- file: crates/apps/game-snake-poc-tauri/USAGE.md -->
+<!-- version: 3 -->
+
+# Utilisation — Snake Tauri Android
+
+## Prérequis locaux
+
+Le host utilise Cargo/Rust, `cargo tauri`, Node/npm, `wasm-bindgen`, Java et le SDK Android. Le dépôt attend `ANDROID_HOME` vers le SDK Android et des NDK side-by-side sous `$ANDROID_HOME/ndk/<version>`.
+
+`NDK_HOME` n'est pas un prérequis utilisateur du projet. Tauri sélectionne la version NDK side-by-side appropriée sous `$ANDROID_HOME/ndk/<version>` et peut injecter lui-même `NDK_HOME` dans ses sous-processus Android. Une variable globale ne doit donc pas être ajoutée uniquement pour satisfaire la documentation générique de Tauri.
+
+Pour Android, `JAVA_HOME` doit pointer vers un JDK compatible avec la chaîne Gradle générée par la version stable de Tauri 2 utilisée par le projet. La documentation Tauri recommande le JBR fourni par Android Studio. Le Java 25 global de la machine de validation n'est pas utilisé pour les commandes Tauri Android tant qu'il reste incompatible avec le wrapper Gradle stable. Le Gradle global installé sur la machine n'est pas utilisé par `gradlew` et n'est pas un prérequis du projet.
+
+Exemple lorsque Android Studio est installé sous `/opt/android-studio` :
+
+```bash
+export JAVA_HOME=/opt/android-studio/jbr
+"$JAVA_HOME/bin/java" -version
+```
+
+Si Android Studio se trouve ailleurs, utiliser le chemin réel de son répertoire `jbr`. Ne pas modifier `gen/android` pour contourner une incompatibilité de JDK.
+
+Pour les cibles actuellement disponibles, `aarch64-linux-android` permet le smoke sur l'appareil ARM64 et `x86_64-linux-android` celui des AVD x86_64. Les autres ABI ne sont pas requises pour `0-pre.2`.
+
+## Initialisation locale
+
+Installer les dépendances frontend dans la crate :
+
+```bash
+(cd crates/apps/game-snake-poc-tauri && npm install)
+```
+
+Initialiser une fois le projet Android généré par Tauri :
+
+```bash
+(cd crates/apps/game-snake-poc-tauri && cargo tauri android init)
+```
+
+Le répertoire `gen/` produit par Tauri est généré et ignoré ; il n'appartient pas aux deltas et ne doit pas être patché par des scripts propres au jeu. Une initialisation déjà réalisée reste utilisable ; il n'est pas nécessaire de rejouer `android init` pour ce fix.
+
+## Smoke Android de développement
+
+Lancer ensuite :
+
+```bash
+(cd crates/apps/game-snake-poc-tauri && cargo tauri android dev)
+```
+
+Choisir l'appareil réel ou l'AVD voulu lorsque la CLI le demande. Le frontend doit afficher une provenance `android / tauri-webview / wasm / unknown / unknown` et les événements de démarrage doivent apparaître dans le tracing/logcat.
+
+Ne pas utiliser `npm run dev` ou `npm run build` comme gate manuelle : ces scripts sont des hooks internes possédés par Tauri. `cargo tauri android build` reste réservé au jalon de packaging prévu par le plan, sauf diagnostic explicite.

crates/apps/game-snake-poc-tauri/build.rs

@@ -0,0 +1,9 @@
+// file: crates/apps/game-snake-poc-tauri/build.rs
+// version: 3
+
+//! Build-time integration for the Snake Tauri host.
+
+fn main() {
+    tauri_build::build();
+    return;
+}

crates/apps/game-snake-poc-tauri/capabilities/default.json

@@ -0,0 +1,12 @@
+{
+    "$schema": "../gen/schemas/desktop-schema.json",
+    "identifier": "default",
+    "description": "Default capability for the Snake Tauri Android POC",
+    "windows": [
+        "main"
+    ],
+    "permissions": [
+        "core:default",
+        "tracing:default"
+    ]
+}

crates/apps/game-snake-poc-tauri/frontend/css/main.css

@@ -0,0 +1,58 @@
+/* file: crates/apps/game-snake-poc-tauri/frontend/css/main.css */
+/* version: 1 */
+
+:root {
+    font-family: system-ui, sans-serif;
+    color-scheme: dark;
+    background: #101418;
+    color: #f4f7f8;
+}
+
+* {
+    box-sizing: border-box;
+}
+
+html,
+body {
+    min-height: 100%;
+    margin: 0;
+}
+
+body {
+    min-height: 100vh;
+    display: grid;
+    place-items: center;
+    padding: max(1.5rem, env(safe-area-inset-top)) max(1.5rem, env(safe-area-inset-right)) max(1.5rem, env(safe-area-inset-bottom))
+        max(1.5rem, env(safe-area-inset-left));
+}
+
+.bootstrap-panel {
+    width: min(100%, 34rem);
+    padding: 1.5rem;
+    border: 1px solid currentColor;
+    border-radius: 0.75rem;
+}
+
+.eyebrow {
+    margin: 0 0 0.5rem;
+    opacity: 0.7;
+}
+
+h1 {
+    margin: 0 0 1rem;
+    font-size: clamp(1.6rem, 7vw, 2.4rem);
+}
+
+#runtime-status {
+    margin: 0 0 0.75rem;
+}
+
+#runtime-provenance {
+    display: block;
+    overflow-wrap: anywhere;
+    font-family: ui-monospace, monospace;
+}
+
+body[data-runtime-state="error"] #runtime-status {
+    font-weight: 700;
+}

crates/apps/game-snake-poc-tauri/frontend/main.html

@@ -0,0 +1,17 @@
+<!doctype html>
+<html lang="fr">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
+        <title>Snake POC Tauri</title>
+    </head>
+    <body>
+        <main class="bootstrap-panel" aria-labelledby="runtime-title">
+            <p class="eyebrow">games.sasedev</p>
+            <h1 id="runtime-title">Snake — Tauri Android</h1>
+            <p id="runtime-status">Initialisation du runtime…</p>
+            <output id="runtime-provenance" aria-live="polite">provenance en attente</output>
+        </main>
+        <script type="module" src="/ts/main.ts"></script>
+    </body>
+</html>

crates/apps/game-snake-poc-tauri/frontend/ts/bridge.ts

@@ -0,0 +1,20 @@
+// file: crates/apps/game-snake-poc-tauri/frontend/ts/bridge.ts
+// version: 1
+
+import { invoke } from "@tauri-apps/api/core";
+
+export interface RuntimeDescriptor {
+    deviceClass: string;
+    executionModel: string;
+    inputProfile: string;
+    platformFamily: string;
+    runtimeHost: string;
+}
+
+export async function getRuntimeDescriptor(): Promise<RuntimeDescriptor> {
+    return await invoke<RuntimeDescriptor>("get_runtime_descriptor");
+}
+
+export async function reportFrontendReady(): Promise<void> {
+    await invoke("frontend_ready");
+}

crates/apps/game-snake-poc-tauri/frontend/ts/logging.ts

@@ -0,0 +1,16 @@
+// file: crates/apps/game-snake-poc-tauri/frontend/ts/logging.ts
+// version: 1
+
+import { attachConsole, error, info } from "@fltsci/tauri-plugin-tracing";
+
+export async function initializeFrontendTracing(): Promise<void> {
+    await attachConsole();
+}
+
+export function frontendInfo(message: string): void {
+    info(message);
+}
+
+export function frontendError(message: string): void {
+    error(message);
+}

crates/apps/game-snake-poc-tauri/frontend/ts/main.ts

@@ -0,0 +1,56 @@
+// file: crates/apps/game-snake-poc-tauri/frontend/ts/main.ts
+// version: 1
+
+import init, { SnakeWasmGame } from "@snake-wasm";
+import "../css/main.css";
+import { getRuntimeDescriptor, reportFrontendReady } from "./bridge";
+import { frontendError, frontendInfo, initializeFrontendTracing } from "./logging";
+
+function requiredElement<T extends HTMLElement>(identifier: string): T {
+    const element = document.getElementById(identifier);
+    if (element === null) {
+        throw new Error(`Élément frontend requis absent : ${identifier}`);
+    }
+    return element as T;
+}
+
+async function bootstrap(): Promise<void> {
+    await initializeFrontendTracing();
+    frontendInfo("Snake Tauri frontend bootstrap started");
+    const descriptor = await getRuntimeDescriptor();
+    await init();
+    const game = new SnakeWasmGame();
+    const configured = game.configure_runtime_provenance(
+        descriptor.platformFamily,
+        descriptor.runtimeHost,
+        descriptor.deviceClass,
+        descriptor.inputProfile,
+    );
+    if (!configured) {
+        game.free();
+        throw new Error("La provenance Tauri Android n'a pas été acceptée par l'adapter Snake WASM.");
+    }
+    const status = requiredElement<HTMLParagraphElement>("runtime-status");
+    const provenance = requiredElement<HTMLOutputElement>("runtime-provenance");
+    status.textContent = "Runtime minimal initialisé. Le Canvas et les contrôles arrivent dans 0-pre.3.";
+    provenance.value = [
+        game.provenance_platform_family(),
+        game.provenance_runtime_host(),
+        game.provenance_execution_model(),
+        game.provenance_device_class(),
+        game.provenance_input_profile(),
+    ].join(" / ");
+    window.addEventListener("pagehide", () => game.free(), { once: true });
+    await reportFrontendReady();
+    frontendInfo(`Snake Tauri frontend ready: ${provenance.value}`);
+}
+
+void bootstrap().catch(reason => {
+    const message = reason instanceof Error ? reason.message : String(reason);
+    document.body.dataset.runtimeState = "error";
+    const status = document.getElementById("runtime-status");
+    if (status !== null) {
+        status.textContent = `Échec d'initialisation : ${message}`;
+    }
+    frontendError(`Snake Tauri frontend bootstrap failed: ${message}`);
+});

crates/apps/game-snake-poc-tauri/package.json

@@ -0,0 +1,21 @@
+{
+    "name": "game-snake-poc-tauri",
+    "private": true,
+    "version": "0.1.0",
+    "type": "module",
+    "scripts": {
+        "wasm:dev": "cargo build -p game-snake-poc-wasm --target wasm32-unknown-unknown && wasm-bindgen ../../../../builds/sasedev-games/target/wasm32-unknown-unknown/debug/game_snake_poc_wasm.wasm --target web --out-dir ../../../../builds/sasedev-games/game-snake-poc-tauri/wasm --out-name game_snake_poc_wasm",
+        "wasm:build": "cargo build -p game-snake-poc-wasm --release --target wasm32-unknown-unknown && wasm-bindgen ../../../../builds/sasedev-games/target/wasm32-unknown-unknown/release/game_snake_poc_wasm.wasm --target web --out-dir ../../../../builds/sasedev-games/game-snake-poc-tauri/wasm --out-name game_snake_poc_wasm",
+        "dev": "npm run wasm:dev && vite",
+        "build": "npm run wasm:build && tsc && vite build"
+    },
+    "dependencies": {
+        "@fltsci/tauri-plugin-tracing": "^0.3",
+        "@tauri-apps/api": "^2.11"
+    },
+    "devDependencies": {
+        "@types/node": "^26.1",
+        "typescript": "^7.0",
+        "vite": "^8.2"
+    }
+}

crates/apps/game-snake-poc-tauri/src/lib.rs

@@ -0,0 +1,21 @@
+// file: crates/apps/game-snake-poc-tauri/src/lib.rs
+// version: 1
+
+//! Tauri Android application facade for the Snake WebAssembly POC.
+
+#![forbid(unsafe_code)]
+#![deny(unreachable_pub)]
+#![warn(missing_docs)]
+
+mod runtime;
+mod tauri;
+
+/// Runs the Snake Tauri application.
+pub use self::tauri::run;
+
+/// Runtime descriptor exposed by the native Tauri bridge.
+pub(crate) use self::runtime::RuntimeDescriptorDto;
+/// Records that the Tauri frontend completed its minimal startup sequence.
+pub(crate) use self::runtime::record_frontend_ready;
+/// Returns the canonical runtime descriptor for the Android WebView host.
+pub(crate) use self::runtime::runtime_descriptor;

crates/apps/game-snake-poc-tauri/src/main.rs

@@ -0,0 +1,20 @@
+// file: crates/apps/game-snake-poc-tauri/src/main.rs
+// version: 1
+
+//! Binary entry point for host-side Snake Tauri checks.
+
+#![forbid(unsafe_code)]
+#![deny(unreachable_pub)]
+#![warn(missing_docs)]
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+fn main() -> std::process::ExitCode {
+    let result = game_snake_poc_tauri_lib::run();
+    return match result {
+        std::result::Result::Ok(()) => std::process::ExitCode::SUCCESS,
+        std::result::Result::Err(error) => {
+            eprintln!("Snake Tauri application error: {error}");
+            std::process::ExitCode::FAILURE
+        },
+    };
+}

crates/apps/game-snake-poc-tauri/src/runtime.rs

@@ -0,0 +1,87 @@
+// file: crates/apps/game-snake-poc-tauri/src/runtime.rs
+// version: 1
+
+/// Stable runtime dimensions exposed to the Tauri frontend.
+#[derive(Clone, Debug, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct RuntimeDescriptorDto {
+    device_class: String,
+    execution_model: String,
+    input_profile: String,
+    platform_family: String,
+    runtime_host: String,
+}
+
+/// Returns the canonical runtime descriptor for the Android WebView host.
+pub(crate) fn runtime_descriptor() -> RuntimeDescriptorDto {
+    let provenance = engine_v1_platform_api::RuntimeProvenance::new(
+        engine_v1_platform_api::DeviceClass::Unknown,
+        engine_v1_platform_api::ExecutionModel::Wasm,
+        engine_v1_platform_api::InputProfile::Unknown,
+        engine_v1_platform_api::PlatformFamily::Android,
+        engine_v1_platform_api::RuntimeHost::TauriWebView,
+    );
+    return RuntimeDescriptorDto {
+        device_class: device_class_label(provenance.device_class()).to_string(),
+        execution_model: execution_model_label(provenance.execution_model()).to_string(),
+        input_profile: input_profile_label(provenance.input_profile()).to_string(),
+        platform_family: platform_family_label(provenance.platform_family()).to_string(),
+        runtime_host: runtime_host_label(provenance.runtime_host()).to_string(),
+    };
+}
+
+/// Records that the Tauri frontend completed its minimal startup sequence.
+pub(crate) fn record_frontend_ready() {
+    let descriptor = crate::runtime_descriptor();
+    tracing::info!(
+        target: "games::tauri::snake",
+        action = "frontend_ready",
+        platform_family = descriptor.platform_family,
+        runtime_host = descriptor.runtime_host,
+        execution_model = descriptor.execution_model,
+        "Snake Tauri frontend ready"
+    );
+    return;
+}
+
+fn device_class_label(value: engine_v1_platform_api::DeviceClass) -> &'static str {
+    return match value {
+        engine_v1_platform_api::DeviceClass::Desktop => "desktop",
+        engine_v1_platform_api::DeviceClass::Phone => "phone",
+        engine_v1_platform_api::DeviceClass::Tablet => "tablet",
+        engine_v1_platform_api::DeviceClass::Unknown => "unknown",
+    };
+}
+
+fn execution_model_label(value: engine_v1_platform_api::ExecutionModel) -> &'static str {
+    return match value {
+        engine_v1_platform_api::ExecutionModel::Native => "native",
+        engine_v1_platform_api::ExecutionModel::Wasm => "wasm",
+    };
+}
+
+fn input_profile_label(value: engine_v1_platform_api::InputProfile) -> &'static str {
+    return match value {
+        engine_v1_platform_api::InputProfile::Gamepad => "gamepad",
+        engine_v1_platform_api::InputProfile::KeyboardMouse => "keyboard-mouse",
+        engine_v1_platform_api::InputProfile::Mixed => "mixed",
+        engine_v1_platform_api::InputProfile::Touch => "touch",
+        engine_v1_platform_api::InputProfile::Unknown => "unknown",
+    };
+}
+
+fn platform_family_label(value: engine_v1_platform_api::PlatformFamily) -> &'static str {
+    return match value {
+        engine_v1_platform_api::PlatformFamily::Android => "android",
+        engine_v1_platform_api::PlatformFamily::Desktop => "desktop",
+        engine_v1_platform_api::PlatformFamily::Web => "web",
+    };
+}
+
+fn runtime_host_label(value: engine_v1_platform_api::RuntimeHost) -> &'static str {
+    return match value {
+        engine_v1_platform_api::RuntimeHost::Browser => "browser",
+        engine_v1_platform_api::RuntimeHost::Native => "native",
+        engine_v1_platform_api::RuntimeHost::TauriWebView => "tauri-webview",
+    };
+}

crates/apps/game-snake-poc-tauri/src/tauri.rs

@@ -0,0 +1,85 @@
+// file: crates/apps/game-snake-poc-tauri/src/tauri.rs
+// version: 2
+
+//! Tauri runtime assembly and Web/Rust commands for the Snake Android POC.
+
+#[tauri::command]
+fn get_runtime_descriptor() -> crate::RuntimeDescriptorDto {
+    return crate::runtime_descriptor();
+}
+
+#[tauri::command]
+fn frontend_ready() {
+    crate::record_frontend_ready();
+    return;
+}
+
+fn configure_plugins(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<tauri::Wry> {
+    let tracing_plugin = tauri_plugin_tracing::Builder::new().build::<tauri::Wry>();
+    return builder.plugin(tracing_plugin);
+}
+
+#[allow(clippy::question_mark_used)] // Tauri generates the question-mark operator internally for command dispatch.
+fn configure_commands(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<tauri::Wry> {
+    return builder.invoke_handler(tauri::generate_handler![get_runtime_descriptor, frontend_ready]);
+}
+
+fn run_runtime() -> std::result::Result<(), String> {
+    let logging_guard = game_logging_lib::init_console_tracing();
+    let _logging_guard = match logging_guard {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    tracing::info!(
+        target: "games::tauri::snake",
+        action = "runtime_start",
+        platform_family = "android",
+        runtime_host = "tauri-webview",
+        execution_model = "wasm",
+        "Starting Snake Tauri Android runtime"
+    );
+    let builder = tauri::Builder::default();
+    let builder = configure_plugins(builder);
+    let builder = configure_commands(builder);
+    return match builder.run(tauri::generate_context!()) {
+        std::result::Result::Ok(()) => {
+            tracing::info!(
+                target: "games::tauri::snake",
+                action = "runtime_stop",
+                "Snake Tauri runtime stopped"
+            );
+            std::result::Result::Ok(())
+        },
+        std::result::Result::Err(error) => {
+            tracing::error!(
+                target: "games::tauri::snake",
+                action = "runtime_error",
+                error = error.to_string(),
+                "Snake Tauri runtime failed"
+            );
+            std::result::Result::Err(error.to_string())
+        },
+    };
+}
+
+/// Runs the Snake Tauri application on a desktop host.
+#[cfg(not(mobile))]
+pub fn run() -> std::result::Result<(), String> {
+    return run_runtime();
+}
+
+/// Runs the Snake Tauri application from Tauri's mobile entry point.
+#[cfg(mobile)]
+#[tauri::mobile_entry_point]
+pub fn run() {
+    let result = run_runtime();
+    if let std::result::Result::Err(error) = result {
+        tracing::error!(
+            target: "games::tauri::snake",
+            action = "mobile_entrypoint_error",
+            error = error.as_str(),
+            "Snake Tauri mobile entry point terminated after a runtime error"
+        );
+    }
+    return;
+}

crates/apps/game-snake-poc-tauri/tauri.conf.json

@@ -0,0 +1,41 @@
+{
+    "$schema": "https://schema.tauri.app/config/2",
+    "productName": "Snake POC Tauri",
+    "identifier": "com.sasedev.games.snake.tauri",
+    "build": {
+        "beforeDevCommand": {
+            "script": "npm run dev",
+            "cwd": "."
+        },
+        "devUrl": "http://localhost:1436",
+        "beforeBuildCommand": {
+            "script": "npm run build",
+            "cwd": "."
+        },
+        "frontendDist": "../../../../builds/sasedev-games/game-snake-poc-tauri/dist"
+    },
+    "app": {
+        "windows": [
+            {
+                "label": "main",
+                "url": "main.html",
+                "title": "Snake POC Tauri",
+                "width": 405,
+                "height": 720,
+                "minWidth": 320,
+                "minHeight": 480,
+                "resizable": true,
+                "center": true
+            }
+        ],
+        "security": {
+            "csp": null
+        }
+    },
+    "bundle": {
+        "active": false,
+        "icon": [
+            "icons/icon.png"
+        ]
+    }
+}

crates/apps/game-snake-poc-tauri/tsconfig.json

@@ -0,0 +1,36 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "useDefineForClassFields": true,
+        "module": "ESNext",
+        "lib": [
+            "ES2022",
+            "DOM",
+            "DOM.Iterable"
+        ],
+        "skipLibCheck": true,
+        "moduleResolution": "bundler",
+        "allowImportingTsExtensions": true,
+        "resolveJsonModule": true,
+        "isolatedModules": true,
+        "noEmit": true,
+        "strict": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noFallthroughCasesInSwitch": true,
+        "allowSyntheticDefaultImports": true,
+        "types": [
+            "vite/client",
+            "node"
+        ],
+        "paths": {
+            "@snake-wasm": [
+                "../../../../builds/sasedev-games/game-snake-poc-tauri/wasm/game_snake_poc_wasm.d.ts"
+            ]
+        }
+    },
+    "include": [
+        "frontend",
+        "vite.config.ts"
+    ]
+}

crates/apps/game-snake-poc-tauri/vite.config.ts

@@ -0,0 +1,72 @@
+// file: crates/apps/game-snake-poc-tauri/vite.config.ts
+// version: 1
+
+import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
+import { defineConfig, normalizePath } from "vite";
+
+const appRoot = fileURLToPath(new URL(".", import.meta.url));
+const repositoryRoot = normalizePath(resolve(appRoot, "../../.."));
+const frontendRoot = normalizePath(resolve(appRoot, "frontend"));
+const externalBuildRoot = normalizePath(resolve(repositoryRoot, "../builds/sasedev-games/game-snake-poc-tauri"));
+const wasmRoot = normalizePath(resolve(externalBuildRoot, "wasm"));
+const wasmModule = normalizePath(resolve(wasmRoot, "game_snake_poc_wasm.js"));
+const frontendDist = normalizePath(resolve(externalBuildRoot, "dist"));
+const viteCacheDir = normalizePath(resolve(externalBuildRoot, "vite-cache"));
+const devHost = process.env.TAURI_DEV_HOST;
+
+export default defineConfig({
+    base: "./",
+    cacheDir: viteCacheDir,
+    clearScreen: false,
+    root: frontendRoot,
+    publicDir: false,
+    input: {
+        main: normalizePath(resolve(frontendRoot, "main.html")),
+    },
+    resolve: {
+        alias: {
+            "@snake-wasm": wasmModule,
+        },
+    },
+    build: {
+        outDir: frontendDist,
+        emptyOutDir: true,
+        minify: true,
+        sourcemap: false,
+        cssCodeSplit: true,
+        rolldownOptions: {
+            output: {
+                entryFileNames: "js/[name]-[hash].js",
+                chunkFileNames: "js/chunks/[name]-[hash].js",
+                assetFileNames: assetInfo => {
+                    const originalName = assetInfo.names[0] ?? "";
+                    const extension = originalName.substring(originalName.lastIndexOf(".") + 1).toLowerCase();
+                    if (extension === "css") {
+                        return "css/[name]-[hash][extname]";
+                    }
+                    if (extension === "wasm") {
+                        return "wasm/[name]-[hash][extname]";
+                    }
+                    return "otherassets/[name][extname]";
+                },
+            },
+        },
+    },
+    server: {
+        port: 1436,
+        strictPort: true,
+        host: devHost || false,
+        fs: {
+            allow: [appRoot, repositoryRoot, externalBuildRoot],
+        },
+        ws: {
+            protocol: "ws",
+            host: devHost || "localhost",
+            port: 1437,
+        },
+        watch: {
+            ignored: ["**/src/**"],
+        },
+    },
+});

crates/apps/game-snake-poc-wasm/Cargo.toml

@@ -0,0 +1,23 @@
+# file: crates/apps/game-snake-poc-wasm/Cargo.toml
+# version: 2
+
+[package]
+name = "game-snake-poc-wasm"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+authors.workspace = true
+publish.workspace = true
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+engine-v1-common = { path = "../../engines/engine-v1-common" }
+engine-v1-platform-api = { path = "../../engines/engine-v1-platform-api" }
+game-snake-poc = { path = "../../games/game-snake-poc" }
+wasm-bindgen.workspace = true
+
+[lints]
+workspace = true

crates/apps/game-snake-poc-wasm/src/lib.rs

@@ -0,0 +1,13 @@
+// file: crates/apps/game-snake-poc-wasm/src/lib.rs
+// version: 1
+
+//! WebAssembly adapter facade for the Snake POC.
+
+#![forbid(unsafe_code)]
+#![deny(unreachable_pub)]
+#![warn(missing_docs)]
+
+mod runtime;
+
+/// Re-export of the Snake WebAssembly runtime adapter.
+pub use self::runtime::SnakeWasmGame;

crates/apps/game-snake-poc-wasm/src/runtime.rs

@@ -0,0 +1,330 @@
+// file: crates/apps/game-snake-poc-wasm/src/runtime.rs
+// version: 3
+
+const FIXED_STEP_MILLIS: u64 = 16;
+
+/// WebAssembly-owned Snake game state consumed by the direct browser host.
+#[wasm_bindgen::prelude::wasm_bindgen]
+pub struct SnakeWasmGame {
+    pending_input: engine_v1_common::InputState,
+    provenance: engine_v1_platform_api::RuntimeProvenance,
+    runner: engine_v1_common::FixedStepRunner,
+    state: game_snake_poc::SnakeState,
+}
+
+#[wasm_bindgen::prelude::wasm_bindgen]
+impl SnakeWasmGame {
+    /// Creates a fresh Snake POC session using the shared gameplay crate.
+    #[wasm_bindgen::prelude::wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        return Self {
+            pending_input: engine_v1_common::InputState::none(),
+            provenance: engine_v1_platform_api::RuntimeProvenance::new(
+                engine_v1_platform_api::DeviceClass::Unknown,
+                engine_v1_platform_api::ExecutionModel::Wasm,
+                engine_v1_platform_api::InputProfile::Unknown,
+                engine_v1_platform_api::PlatformFamily::Web,
+                engine_v1_platform_api::RuntimeHost::Browser,
+            ),
+            runner: engine_v1_common::FixedStepRunner::new(std::time::Duration::from_millis(FIXED_STEP_MILLIS)),
+            state: game_snake_poc::SnakeState::new(),
+        };
+    }
+
+    /// Updates host-observed runtime provenance while preserving WebAssembly execution.
+    pub fn configure_runtime_provenance(&mut self, platform_family: &str, runtime_host: &str, device_class: &str, input_profile: &str) -> bool {
+        let platform_family = match parse_platform_family(platform_family) {
+            Some(value) => value,
+            None => return false,
+        };
+        let runtime_host = match parse_runtime_host(runtime_host) {
+            Some(value) => value,
+            None => return false,
+        };
+        let device_class = match parse_device_class(device_class) {
+            Some(value) => value,
+            None => return false,
+        };
+        let input_profile = match parse_input_profile(input_profile) {
+            Some(value) => value,
+            None => return false,
+        };
+        self.provenance = engine_v1_platform_api::RuntimeProvenance::new(
+            device_class,
+            engine_v1_platform_api::ExecutionModel::Wasm,
+            input_profile,
+            platform_family,
+            runtime_host,
+        );
+        return true;
+    }
+
+    /// Returns the current physical device class label.
+    pub fn provenance_device_class(&self) -> String {
+        return device_class_label(self.provenance.device_class()).to_string();
+    }
+
+    /// Returns the current execution model label.
+    pub fn provenance_execution_model(&self) -> String {
+        return execution_model_label(self.provenance.execution_model()).to_string();
+    }
+
+    /// Returns the current primary input profile label.
+    pub fn provenance_input_profile(&self) -> String {
+        return input_profile_label(self.provenance.input_profile()).to_string();
+    }
+
+    /// Returns the current platform family label.
+    pub fn provenance_platform_family(&self) -> String {
+        return platform_family_label(self.provenance.platform_family()).to_string();
+    }
+
+    /// Returns the current runtime host label.
+    pub fn provenance_runtime_host(&self) -> String {
+        return runtime_host_label(self.provenance.runtime_host()).to_string();
+    }
+
+    /// Queues a logical left direction for the next deterministic update.
+    pub fn left(&mut self) {
+        self.queue_direction(engine_v1_common::GameAction::Left);
+        return;
+    }
+
+    /// Queues a logical right direction for the next deterministic update.
+    pub fn right(&mut self) {
+        self.queue_direction(engine_v1_common::GameAction::Right);
+        return;
+    }
+
+    /// Queues a logical upward direction for the next deterministic update.
+    pub fn up(&mut self) {
+        self.queue_direction(engine_v1_common::GameAction::Up);
+        return;
+    }
+
+    /// Queues a logical downward direction for the next deterministic update.
+    pub fn down(&mut self) {
+        self.queue_direction(engine_v1_common::GameAction::Down);
+        return;
+    }
+
+    /// Advances one deterministic update and consumes the queued direction.
+    pub fn tick(&mut self) {
+        let input = self.pending_input;
+        self.pending_input = engine_v1_common::InputState::none();
+        self.runner.tick(&mut self.state, input);
+        return;
+    }
+
+    /// Returns the current gameplay score.
+    pub fn score(&self) -> u32 {
+        return self.state.score().min(u32::MAX as u64) as u32;
+    }
+
+    /// Returns the current Snake length.
+    pub fn length(&self) -> u32 {
+        return self.state.length().min(u32::MAX as usize) as u32;
+    }
+
+    /// Returns the current scene background red channel.
+    pub fn background_red(&self) -> u8 {
+        return self.scene().background().red();
+    }
+
+    /// Returns the current scene background green channel.
+    pub fn background_green(&self) -> u8 {
+        return self.scene().background().green();
+    }
+
+    /// Returns the current scene background blue channel.
+    pub fn background_blue(&self) -> u8 {
+        return self.scene().background().blue();
+    }
+
+    /// Returns the number of occupied rectangle slots in the current scene.
+    pub fn rectangle_count(&self) -> u32 {
+        let scene = self.scene();
+        let mut count = 0_u32;
+        for slot in scene.rectangles() {
+            if slot.is_some() {
+                count = count.saturating_add(1);
+            }
+        }
+        return count;
+    }
+
+    /// Returns one rectangle's normalized left coordinate or `-1.0` if absent.
+    pub fn rectangle_x(&self, index: u32) -> f32 {
+        return match self.rectangle(index) {
+            Some(rectangle) => rectangle.rect().x(),
+            None => -1.0,
+        };
+    }
+
+    /// Returns one rectangle's normalized top coordinate or `-1.0` if absent.
+    pub fn rectangle_y(&self, index: u32) -> f32 {
+        return match self.rectangle(index) {
+            Some(rectangle) => rectangle.rect().y(),
+            None => -1.0,
+        };
+    }
+
+    /// Returns one rectangle's normalized width or `0.0` if absent.
+    pub fn rectangle_width(&self, index: u32) -> f32 {
+        return match self.rectangle(index) {
+            Some(rectangle) => rectangle.rect().width(),
+            None => 0.0,
+        };
+    }
+
+    /// Returns one rectangle's normalized height or `0.0` if absent.
+    pub fn rectangle_height(&self, index: u32) -> f32 {
+        return match self.rectangle(index) {
+            Some(rectangle) => rectangle.rect().height(),
+            None => 0.0,
+        };
+    }
+
+    /// Returns one rectangle's red channel or zero if absent.
+    pub fn rectangle_red(&self, index: u32) -> u8 {
+        return match self.rectangle(index) {
+            Some(rectangle) => rectangle.color().red(),
+            None => 0,
+        };
+    }
+
+    /// Returns one rectangle's green channel or zero if absent.
+    pub fn rectangle_green(&self, index: u32) -> u8 {
+        return match self.rectangle(index) {
+            Some(rectangle) => rectangle.color().green(),
+            None => 0,
+        };
+    }
+
+    /// Returns one rectangle's blue channel or zero if absent.
+    pub fn rectangle_blue(&self, index: u32) -> u8 {
+        return match self.rectangle(index) {
+            Some(rectangle) => rectangle.color().blue(),
+            None => 0,
+        };
+    }
+}
+
+impl Default for SnakeWasmGame {
+    fn default() -> Self {
+        return Self::new();
+    }
+}
+
+impl SnakeWasmGame {
+    fn queue_direction(&mut self, action: engine_v1_common::GameAction) {
+        self.pending_input = engine_v1_common::InputState::none().with_action(action, true);
+        return;
+    }
+
+    fn scene(&self) -> engine_v1_common::EngineScene {
+        return engine_v1_common::EngineGame::scene(&self.state);
+    }
+
+    fn rectangle(&self, requested_index: u32) -> Option<engine_v1_common::RenderRect> {
+        let scene = self.scene();
+        let mut occupied_index = 0_u32;
+        for slot in scene.rectangles() {
+            match slot {
+                Some(rectangle) => {
+                    if occupied_index == requested_index {
+                        return Some(*rectangle);
+                    }
+                    occupied_index = occupied_index.saturating_add(1);
+                },
+                None => {},
+            }
+        }
+        return None;
+    }
+}
+
+fn parse_platform_family(label: &str) -> Option<engine_v1_platform_api::PlatformFamily> {
+    return match label {
+        "android" => Some(engine_v1_platform_api::PlatformFamily::Android),
+        "desktop" => Some(engine_v1_platform_api::PlatformFamily::Desktop),
+        "web" => Some(engine_v1_platform_api::PlatformFamily::Web),
+        _ => None,
+    };
+}
+
+fn parse_runtime_host(label: &str) -> Option<engine_v1_platform_api::RuntimeHost> {
+    return match label {
+        "browser" => Some(engine_v1_platform_api::RuntimeHost::Browser),
+        "native" => Some(engine_v1_platform_api::RuntimeHost::Native),
+        "tauri-webview" => Some(engine_v1_platform_api::RuntimeHost::TauriWebView),
+        _ => None,
+    };
+}
+
+fn parse_device_class(label: &str) -> Option<engine_v1_platform_api::DeviceClass> {
+    return match label {
+        "desktop" => Some(engine_v1_platform_api::DeviceClass::Desktop),
+        "phone" => Some(engine_v1_platform_api::DeviceClass::Phone),
+        "tablet" => Some(engine_v1_platform_api::DeviceClass::Tablet),
+        "unknown" => Some(engine_v1_platform_api::DeviceClass::Unknown),
+        _ => None,
+    };
+}
+
+fn parse_input_profile(label: &str) -> Option<engine_v1_platform_api::InputProfile> {
+    return match label {
+        "gamepad" => Some(engine_v1_platform_api::InputProfile::Gamepad),
+        "keyboard-mouse" => Some(engine_v1_platform_api::InputProfile::KeyboardMouse),
+        "mixed" => Some(engine_v1_platform_api::InputProfile::Mixed),
+        "touch" => Some(engine_v1_platform_api::InputProfile::Touch),
+        "unknown" => Some(engine_v1_platform_api::InputProfile::Unknown),
+        _ => None,
+    };
+}
+
+fn device_class_label(value: engine_v1_platform_api::DeviceClass) -> &'static str {
+    return match value {
+        engine_v1_platform_api::DeviceClass::Desktop => "desktop",
+        engine_v1_platform_api::DeviceClass::Phone => "phone",
+        engine_v1_platform_api::DeviceClass::Tablet => "tablet",
+        engine_v1_platform_api::DeviceClass::Unknown => "unknown",
+    };
+}
+
+fn execution_model_label(value: engine_v1_platform_api::ExecutionModel) -> &'static str {
+    return match value {
+        engine_v1_platform_api::ExecutionModel::Native => "native",
+        engine_v1_platform_api::ExecutionModel::Wasm => "wasm",
+    };
+}
+
+fn input_profile_label(value: engine_v1_platform_api::InputProfile) -> &'static str {
+    return match value {
+        engine_v1_platform_api::InputProfile::Gamepad => "gamepad",
+        engine_v1_platform_api::InputProfile::KeyboardMouse => "keyboard-mouse",
+        engine_v1_platform_api::InputProfile::Mixed => "mixed",
+        engine_v1_platform_api::InputProfile::Touch => "touch",
+        engine_v1_platform_api::InputProfile::Unknown => "unknown",
+    };
+}
+
+fn platform_family_label(value: engine_v1_platform_api::PlatformFamily) -> &'static str {
+    return match value {
+        engine_v1_platform_api::PlatformFamily::Android => "android",
+        engine_v1_platform_api::PlatformFamily::Desktop => "desktop",
+        engine_v1_platform_api::PlatformFamily::Web => "web",
+    };
+}
+
+fn runtime_host_label(value: engine_v1_platform_api::RuntimeHost) -> &'static str {
+    return match value {
+        engine_v1_platform_api::RuntimeHost::Browser => "browser",
+        engine_v1_platform_api::RuntimeHost::Native => "native",
+        engine_v1_platform_api::RuntimeHost::TauriWebView => "tauri-webview",
+    };
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/runtime.rs"]
+mod tests;

crates/apps/game-snake-poc-wasm/unit_tests/runtime.rs

@@ -0,0 +1,63 @@
+// file: crates/apps/game-snake-poc-wasm/unit_tests/runtime.rs
+// version: 3
+
+#[test]
+fn direction_is_queued_without_advancing_simulation() {
+    let mut game = crate::SnakeWasmGame::new();
+    let before_x = game.rectangle_x(1);
+    let before_y = game.rectangle_y(1);
+    game.up();
+    assert_eq!(game.rectangle_x(1), before_x);
+    assert_eq!(game.rectangle_y(1), before_y);
+    game.tick();
+    assert_eq!(game.rectangle_x(1), before_x);
+    assert!(game.rectangle_y(1) < before_y);
+}
+
+#[test]
+fn scene_and_status_are_exposed_for_canvas_host() {
+    let game = crate::SnakeWasmGame::new();
+    assert_eq!(game.score(), 0);
+    assert_eq!(game.length(), 3);
+    assert_eq!(game.rectangle_count(), 4);
+    assert!(game.rectangle_width(0) > 0.0);
+    assert!(game.rectangle_height(0) > 0.0);
+    assert_eq!(game.rectangle_x(99), -1.0);
+    assert_eq!(game.rectangle_y(99), -1.0);
+}
+
+#[test]
+fn browser_runtime_provenance_preserves_static_and_observed_dimensions() {
+    let mut game = crate::SnakeWasmGame::new();
+    assert_eq!(game.provenance_platform_family(), "web");
+    assert_eq!(game.provenance_execution_model(), "wasm");
+    assert_eq!(game.provenance_runtime_host(), "browser");
+    assert_eq!(game.provenance_device_class(), "unknown");
+    assert_eq!(game.provenance_input_profile(), "unknown");
+    assert!(game.configure_runtime_provenance("web", "browser", "phone", "touch"));
+    assert_eq!(game.provenance_device_class(), "phone");
+    assert_eq!(game.provenance_input_profile(), "touch");
+    assert_eq!(game.provenance_platform_family(), "web");
+    assert_eq!(game.provenance_execution_model(), "wasm");
+    assert_eq!(game.provenance_runtime_host(), "browser");
+}
+
+#[test]
+fn invalid_runtime_provenance_labels_are_rejected_without_mutation() {
+    let mut game = crate::SnakeWasmGame::new();
+    assert!(game.configure_runtime_provenance("web", "browser", "desktop", "keyboard-mouse"));
+    assert!(!game.configure_runtime_provenance("console", "spaceship", "console", "telepathy"));
+    assert_eq!(game.provenance_device_class(), "desktop");
+    assert_eq!(game.provenance_input_profile(), "keyboard-mouse");
+}
+
+#[test]
+fn tauri_android_runtime_provenance_is_supported_by_the_shared_adapter() {
+    let mut game = crate::SnakeWasmGame::new();
+    assert!(game.configure_runtime_provenance("android", "tauri-webview", "phone", "touch"));
+    assert_eq!(game.provenance_platform_family(), "android");
+    assert_eq!(game.provenance_runtime_host(), "tauri-webview");
+    assert_eq!(game.provenance_execution_model(), "wasm");
+    assert_eq!(game.provenance_device_class(), "phone");
+    assert_eq!(game.provenance_input_profile(), "touch");
+}

crates/engines/engine-v1-platform-api/src/environment.rs

@@ -1,5 +1,5 @@
 // file: crates/engines/engine-v1-platform-api/src/environment.rs
-// version: 1
+// version: 2
 
 /// Broad physical device class relevant to interaction and score provenance.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -56,7 +56,7 @@ pub enum RuntimeHost {
     Browser,
     /// Native process managed directly by the operating system.
     Native,
-    /// Tauri desktop WebView host.
+    /// Tauri WebView host on a supported native platform.
     TauriWebView,
 }
 

crates/games/game-reflex-poc/Cargo.toml

@@ -1,5 +1,5 @@
 # file: crates/games/game-reflex-poc/Cargo.toml
-# version: 3
+# version: 4
 
 [package]
 name = "game-reflex-poc"
@@ -12,7 +12,6 @@ publish.workspace = true
 
 [dependencies]
 engine-v1-common = { path = "../../engines/engine-v1-common" }
-engine-v1-platform-api = { path = "../../engines/engine-v1-platform-api" }
 
 [dev-dependencies]
 game-logging-lib = { path = "../../common/game-logging-lib" }

crates/games/game-snake-poc/Cargo.toml

@@ -1,5 +1,5 @@
 # file: crates/games/game-snake-poc/Cargo.toml
-# version: 3
+# version: 4
 
 [package]
 name = "game-snake-poc"
@@ -12,7 +12,6 @@ publish.workspace = true
 
 [dependencies]
 engine-v1-common = { path = "../../engines/engine-v1-common" }
-engine-v1-platform-api = { path = "../../engines/engine-v1-platform-api" }
 
 [dev-dependencies]
 game-logging-lib = { path = "../../common/game-logging-lib" }

deltas/0.2.0/0-pre.1.fix.1.delete.txt

@@ -0,0 +1,3 @@
+docs/ideas/README.md
+docs/studies/README.md
+history/README.md

deltas/0.2.0/0-pre.1.fix.1.md

@@ -0,0 +1,121 @@
+<!-- file: deltas/0.2.0/0-pre.1.fix.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.1.fix.1
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.1`.
+
+La prerelease précédente reste une candidate documentaire non validée. Ce fix corrige et complète les règles de gouvernance avant toute progression vers `0-pre.2`.
+
+## Documentation et nomenclature
+
+- adoption de `000-README.md` comme point d'entrée des répertoires documentaires multi-fichiers ;
+- renommage de `docs/ideas/README.md`, `docs/studies/README.md` et `history/README.md` ;
+- généralisation des marqueurs `( )`, `(x)`, `(d)`, `(c)` à toute liste durable de tâches ou d'état, pas seulement au ROADMAP ;
+- conservation des listes descriptives simples sans marqueur artificiel.
+
+## Plateformes
+
+La conception réserve désormais explicitement :
+
+- Desktop : Linux, Windows, macOS ;
+- Mobile : Android, iOS ;
+- Web : navigateur/WASM.
+
+Téléphone et tablette restent des classes de device séparées de l'OS et du backend technique. SDL3 reste le backend natif de référence du POC sans devenir l'identité architecturale d'une plateforme.
+
+## Tauri et versions
+
+- `tauri.conf.json` n'embarque plus de version produit et laisse Tauri utiliser la version Cargo ;
+- `package.json` n'est plus synchronisé à chaque `pre.N` / `.fix.N` et revient à la dernière version frontend significative `0.1.0` pendant cette phase documentaire ;
+- Cargo reste la source canonique de version produit.
+
+## Workflow RC et prompt suivant
+
+- une RC est fonctionnellement gelée ;
+- les bugfixes, corrections de tests, packaging, sécurité et défauts de release peuvent modifier du code sans retour automatique en beta ;
+- une réouverture fonctionnelle de la RC nécessite de revenir à une phase de développement adaptée, normalement beta ;
+- le prompt de la version suivante devient recommandé après validation de la première RC réellement gelée, puis peut être affiné jusqu'à la stable.
+
+## Planification des versions de code
+
+Le cycle conceptuel est :
+
+```text
+PLAN → IMPLEMENT → INTEGRATE → VALIDATE → CANDIDATE → RELEASE
+```
+
+Ces phases n'imposent pas une prerelease chacune. Une petite version peut combiner PLAN et première implémentation dans `pre.1`; une version lourde peut réserver `pre.1` à la décomposition.
+
+## Matrice de validation
+
+Ajout de `docs/rules/RULES_VALIDATION_MATRIX.md` avec :
+
+- identifiants stables `CMD-*` ;
+- dépendances entre commandes ;
+- portée ciblée par crate ;
+- propagation vers les consommateurs impactés ;
+- gates Desktop, Tauri et Android ;
+- règles beta/RC ;
+- commandes de maintenance disque.
+
+## Politique Cargo clean
+
+Le besoin de contrôle disque est reconnu explicitement.
+
+`cargo clean` complet peut être planifié périodiquement à un jalon de cycle afin d'éviter l'accumulation de dizaines ou centaines de Go sous `../builds/sasedev-games/target`.
+
+Entre deux cleans complets, utiliser si pertinent :
+
+```bash
+cargo clean -p <package>
+cargo clean --release
+cargo clean --profile <profile>
+cargo clean --target <triple>
+cargo clean --dry-run --verbose
+```
+
+Il n'existe pas de contrat projet consistant à conserver automatiquement « uniquement la dernière génération utile » des artefacts Cargo : les nettoyages ciblés ou complets sont donc des opérations explicites.
+
+## Suppressions nécessaires
+
+Un overlay ZIP ne supprime pas les anciens fichiers. Après extraction du delta, appliquer :
+
+```bash
+while IFS= read -r path; do
+    rm -rf -- "$path"
+done < deltas/0.2.0/0-pre.1.fix.1.delete.txt
+```
+
+## Validation automatique
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+La suppression de `version` dans `tauri.conf.json` modifie une configuration de build. Une vérification Tauri est donc recommandée avant validation définitive du fix :
+
+```bash
+(cd crates/apps/game-reflex-poc-tauri && cargo tauri build)
+```
+
+Aucun smoke gameplay supplémentaire n'est requis si le build Tauri est propre, car le gameplay et le runtime ne sont pas modifiés.
+
+## Validation humaine
+
+Relire prioritairement :
+
+- `docs/rules/RULES_DOCUMENTATION.md` ;
+- `docs/rules/RULES_COMMANDS.md` ;
+- `docs/rules/RULES_VALIDATION_MATRIX.md` ;
+- `docs/rules/VERSION_WORKFLOW.md` ;
+- `docs/rules/FILE_CONTRACTS.md` ;
+- `docs/architecture/003-SDL3_PLATFORM_ABSTRACTION.md` ;
+- `docs/rules/RULES_PROJECT.md` ;
+- `prompts/001-V0_2_0_START_PROMPT.md`.
+
+Ce fix ne valide toujours pas le catalogue fonctionnel `0.2.0` : la progression vers `0-pre.2` dépend de la revue humaine de cette gouvernance.

deltas/0.2.0/0-pre.1.fix.2.md

@@ -0,0 +1,63 @@
+<!-- file: deltas/0.2.0/0-pre.1.fix.2.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.1.fix.2
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.1.fix.1`.
+
+## Objet
+
+Ce fix formalise l'immuabilité des deltas, le contrat des manifests de suppression et l'incrément obligatoire des versions d'en-tête.
+
+Les deltas déjà livrés ne sont pas modifiés.
+
+## Deltas immuables
+
+- un fichier `deltas/**/*.md` livré est immuable sur le fond ;
+- seules les corrections non sémantiques de forme peuvent toucher le fichier existant ;
+- toute correction de forme autorisée incrémente son en-tête `version` ;
+- toute correction sémantique ou tout ajout produit un nouveau delta ou `.fix.N`.
+
+## Manifests `*.delete.txt`
+
+Les manifests de suppression sont désormais un contrat documenté :
+
+- un chemin relatif à la racine par ligne ;
+- aucune commande shell dans le manifest ;
+- le delta Markdown associé décrit la raison de chaque groupe de suppressions ;
+- le delta Markdown associé fournit la procédure d'application ;
+- toute modification sémantique des suppressions passe par un nouveau delta/fix.
+
+## Versions d'en-tête
+
+Toute modification réelle d'un fichier versionné incrémente son en-tête `version`.
+
+Les seuls changements qui n'imposent pas cet incrément sont les transformations purement mécaniques réalisées par un formatter officiel, sans autre modification réelle.
+
+Un renommage qui modifie l'en-tête `file:` compte comme une modification réelle.
+
+## Fichiers modifiés par ce fix
+
+- `Cargo.toml` ;
+- `Android/game-reflex-poc/build.gradle` ;
+- `Android/game-snake-poc/build.gradle` ;
+- `README.md` ;
+- `docs/rules/RULES_DOCUMENTATION.md` ;
+- `docs/rules/FILE_CONTRACTS.md` ;
+- `docs/rules/VERSION_WORKFLOW.md` ;
+- `docs/rules/RULES_PROJECT.md` ;
+- `docs/rules/RULES_VALIDATION_MATRIX.md`.
+
+Tous les fichiers ci-dessus qui possèdent un en-tête de version ont été incrémentés.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucun code Rust, Java ou TypeScript n'est modifié dans ce fix.

deltas/0.2.0/0-pre.1.md

@@ -0,0 +1,65 @@
+<!-- file: deltas/0.2.0/0-pre.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.1
+
+## Base
+
+Base déclarée : `0.1.0`.
+
+## Objet
+
+Première prerelease documentaire de `0.2.0`.
+
+Cette tranche ne fige pas encore le catalogue complet des capabilities ni l'architecture cible du framework. Elle fixe d'abord la méthode de conception et de documentation qui sera utilisée pour les prereleases suivantes.
+
+## Contenu
+
+- passage de la version workspace et des métadonnées produit à `0.2.0-0-pre.1` ;
+- correction de la version courante affichée dans `README.md` ;
+- renforcement de `RULES_DOCUMENTATION.md` ;
+- création des contrats `docs/ideas/` et `docs/studies/` ;
+- adoption des marqueurs ROADMAP `( )`, `(x)`, `(d)`, `(c)` ;
+- définition des reports et annulations partiels avec conservation de l'historique de planning ;
+- migration du ROADMAP existant vers la nouvelle convention ;
+- limitation du CHANGELOG aux jalons RC et stables ;
+- migration ponctuelle du CHANGELOG `0.1.0`, les détails retirés restant dans `deltas/` et `history/` ;
+- définition de la maturation des idées et capabilities ;
+- formalisation de la validation humaine des versions documentaires ;
+- réécriture du prompt `0.2.0` pour imposer une conception progressive par prereleases.
+
+## Hors scope
+
+Cette prerelease ne doit pas encore :
+
+- produire le catalogue exhaustif des capabilities ;
+- figer la matrice complète des plateformes ;
+- figer l'architecture future des crates ;
+- planifier définitivement les versions d'implémentation ;
+- créer de nouvelles crates de capability ;
+- modifier le gameplay ou les runtimes existants.
+
+## Validation automatique
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune gate Cargo, Gradle ou smoke test n'est requise pour accepter le fond de cette prerelease : elle ne modifie aucun source Rust, Java, TypeScript ou contrat runtime. La cohérence de version des manifests doit toutefois être relue.
+
+## Validation humaine
+
+La prerelease n'est considérée validée qu'après revue explicite des documents, notamment :
+
+- `docs/rules/RULES_DOCUMENTATION.md` ;
+- `docs/rules/FILE_CONTRACTS.md` ;
+- `docs/rules/VERSION_WORKFLOW.md` ;
+- `ROADMAP.md` ;
+- `CHANGELOG.md` ;
+- `docs/ideas/000-README.md` ;
+- `docs/studies/000-README.md` ;
+- `prompts/001-V0_2_0_START_PROMPT.md`.
+
+Les omissions, ambiguïtés ou règles contestées doivent être corrigées dans `0.2.0-0-pre.1.fix.N` si elles invalident cette candidate, ou traitées dans `0-pre.2` lorsqu'elles constituent la suite normale de conception.

deltas/0.2.0/0-pre.2.fix.1.md

@@ -0,0 +1,80 @@
+<!-- file: deltas/0.2.0/0-pre.2.fix.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.2.fix.1
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.2`.
+
+Le delta `0-pre.2.md` reste immuable.
+
+## Objet
+
+Corriger la présentation normative du tableau de plateformes et compléter l'étude des capacités serveur nécessaires au multijoueur temps réel.
+
+## Tableau plateforme
+
+`docs/studies/003-PLATFORM_CAPABILITY_STUDY.md` utilise désormais des marqueurs d'alignement Markdown explicites.
+
+La convention documentaire est précisée :
+
+- colonne textuelle : `:---` ;
+- colonne numérique : `---:` ;
+- valeur courte réellement destinée à être centrée : `:---:`.
+
+Le tableau actuel de plateformes ne contenant que des valeurs textuelles, toutes ses colonnes sont alignées explicitement à gauche.
+
+## Realtime multiplayer
+
+L'inventaire serveur est complété afin de distinguer :
+
+- API/Web non temps réel ;
+- lobby/matchmaking/session control ;
+- realtime data plane ;
+- synchronisation client ;
+- chat/presence.
+
+Une étude dédiée couvre notamment :
+
+- WebSocket/gateway ;
+- tick serveur ;
+- ingestion et sequencing des inputs ;
+- état authoritative ;
+- snapshots et deltas ;
+- revisions/acks ;
+- interpolation/prediction/reconciliation ;
+- rollback lorsque nécessaire ;
+- reconnect/resync ;
+- rooms et session routing ;
+- interest management ;
+- backpressure ;
+- persistence hors boucle temps réel ;
+- observability ;
+- scaling.
+
+## Fichiers modifiés
+
+- `Cargo.toml` ;
+- `Android/game-reflex-poc/build.gradle` ;
+- `Android/game-snake-poc/build.gradle` ;
+- `README.md` ;
+- `docs/rules/RULES_DOCUMENTATION.md` ;
+- `docs/studies/000-README.md` ;
+- `docs/studies/001-FUNCTIONAL_CAPABILITY_INVENTORY.md` ;
+- `docs/studies/003-PLATFORM_CAPABILITY_STUDY.md` ;
+- `docs/studies/004-GAME_ARCHETYPE_PRESSURE_TEST.md` ;
+- `docs/studies/005-DEPENDENCY_AND_COMPOSITION_STUDY.md` ;
+- `docs/studies/006-REALTIME_MULTIPLAYER_SERVER_STUDY.md`.
+
+Tous les fichiers existants modifiés et possédant un en-tête `version` ont été incrémentés.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune gate Cargo/Gradle/smoke supplémentaire n'est requise : aucun code runtime ou configuration de build n'est modifié hors métadonnées de version.

deltas/0.2.0/0-pre.2.fix.2.md

@@ -0,0 +1,43 @@
+<!-- file: deltas/0.2.0/0-pre.2.fix.2.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.2.fix.2
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.2.fix.1`.
+
+Le delta `0-pre.2.fix.1.md` reste immuable.
+
+## Objet
+
+Correction strictement documentaire des erreurs détectées par `scripts/audit_markdown_tables.py`.
+
+## Corrections
+
+- alignement vertical complet du tableau de `docs/studies/003-PLATFORM_CAPABILITY_STUDY.md` ;
+- conservation de l'alignement Markdown sémantique à gauche pour les colonnes textuelles ;
+- suppression d'une double ligne vide interdite dans `docs/studies/005-DEPENDENCY_AND_COMPOSITION_STUDY.md`.
+
+Aucun contenu fonctionnel ou architectural n'est ajouté ou modifié.
+
+## Fichiers modifiés
+
+- `Cargo.toml` ;
+- `Android/game-reflex-poc/build.gradle` ;
+- `Android/game-snake-poc/build.gradle` ;
+- `README.md` ;
+- `docs/studies/003-PLATFORM_CAPABILITY_STUDY.md` ;
+- `docs/studies/005-DEPENDENCY_AND_COMPOSITION_STUDY.md`.
+
+Les fichiers existants modifiés et possédant un en-tête `version` ont été incrémentés.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune gate Cargo, Gradle ou smoke n'est requise : ce fix ne touche ni code runtime ni configuration de build, hors métadonnées de version.

deltas/0.2.0/0-pre.2.fix.3.md

@@ -0,0 +1,53 @@
+<!-- file: deltas/0.2.0/0-pre.2.fix.3.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.2.fix.3
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.2.fix.2`.
+
+Les deltas précédents restent immuables.
+
+## Objet
+
+Corriger le format du tableau de plateformes selon la convention exacte déjà contrôlée par `scripts/audit_markdown_tables.py`, héritée des outils KSP.
+
+## Convention corrigée
+
+La convention est désormais documentée ainsi :
+
+- toutes les lignes de contenu ont une largeur brute identique par colonne ;
+- les cellules de contenu utilisent les espaces de padding nécessaires ;
+- la cellule de la ligne séparatrice ne contient aucun espace ;
+- elle est composée de tirets sur exactement toute la largeur brute de la colonne ;
+- les marqueurs `:` éventuels remplacent des tirets et ne changent jamais cette largeur.
+
+Exemple :
+
+```markdown
+| Colonne A | Colonne B      |
+|-----------|----------------|
+| valeur    | autre valeur   |
+```
+
+## Fichiers modifiés
+
+- `Cargo.toml` ;
+- `Android/game-reflex-poc/build.gradle` ;
+- `Android/game-snake-poc/build.gradle` ;
+- `README.md` ;
+- `docs/rules/RULES_DOCUMENTATION.md` ;
+- `docs/studies/003-PLATFORM_CAPABILITY_STUDY.md`.
+
+Tous les fichiers existants modifiés et possédant un en-tête `version` ont été incrémentés.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucun contenu fonctionnel n'est ajouté dans ce fix.

deltas/0.2.0/0-pre.2.md

@@ -0,0 +1,65 @@
+<!-- file: deltas/0.2.0/0-pre.2.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.2
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.1.fix.2`.
+
+## Objet
+
+Étudier les fonctionnalités plausibles déjà justifiées et leur ownership architectural sans encore planifier les POC techniques ni le premier projet réel.
+
+## Contenu
+
+- enregistrement du jalon `0-pre.1.fix.2` validé dans `history/` ;
+- inventaire fonctionnel initial ;
+- distinction kernel / technical capability / game-system / platform adapter / provider / server service / tooling / game-specific ;
+- étude des axes OS, device, execution model, host et backend ;
+- pressure test par plusieurs archétypes de jeux ;
+- étude des dépendances et de la composition statique ;
+- conservation de macOS/iOS comme plateformes réservées ;
+- absence volontaire de création de nouvelles crates.
+
+## Hors scope
+
+Cette prerelease ne :
+
+- fige pas encore l'architecture normative ;
+- ne crée pas le manifest produit définitif ;
+- ne planifie pas encore le POC Tauri Android ;
+- ne planifie pas le premier jeu réel ;
+- n'implémente aucune capability ;
+- ne crée aucune nouvelle crate runtime.
+
+## Validation automatique
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune gate Cargo/Gradle/smoke n'est requise par le contenu fonctionnel de cette tranche : aucun code runtime ou build n'est modifié.
+
+## Validation humaine
+
+Relire en priorité :
+
+- `docs/studies/001-FUNCTIONAL_CAPABILITY_INVENTORY.md` ;
+- `docs/studies/002-LAYERING_AND_OWNERSHIP_STUDY.md` ;
+- `docs/studies/003-PLATFORM_CAPABILITY_STUDY.md` ;
+- `docs/studies/004-GAME_ARCHETYPE_PRESSURE_TEST.md` ;
+- `docs/studies/005-DEPENDENCY_AND_COMPOSITION_STUDY.md`.
+
+La revue doit notamment signaler :
+
+- fonctionnalités manquantes ;
+- fonctionnalités sur-réservées ;
+- mauvais ownership ;
+- dépendances trop fortes ;
+- confusion entre capability et game-system ;
+- limites plateforme oubliées.
+
+Les décisions retenues seront seulement ensuite promues vers `docs/architecture/`.

deltas/0.2.0/0-pre.3.fix.1.md

@@ -0,0 +1,39 @@
+<!-- file: deltas/0.2.0/0-pre.3.fix.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.3.fix.1
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.3`.
+
+Le delta `0-pre.3.md` reste immuable.
+
+## Objet
+
+Correction strictement documentaire d'une double ligne vide interdite par `scripts/audit_markdown_tables.py`.
+
+## Correction
+
+- suppression de la double ligne vide dans `docs/studies/005-DEPENDENCY_AND_COMPOSITION_STUDY.md` ;
+- aucun ajout fonctionnel ou architectural.
+
+## Fichiers modifiés
+
+- `Cargo.toml` ;
+- `Android/game-reflex-poc/build.gradle` ;
+- `Android/game-snake-poc/build.gradle` ;
+- `README.md` ;
+- `docs/studies/005-DEPENDENCY_AND_COMPOSITION_STUDY.md`.
+
+Tous les fichiers existants modifiés et possédant un en-tête `version` ont été incrémentés.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune gate Cargo, Gradle ou smoke n'est requise.

deltas/0.2.0/0-pre.3.md

@@ -0,0 +1,66 @@
+<!-- file: deltas/0.2.0/0-pre.3.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.3
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.2.fix.3`.
+
+## Objet
+
+Compléter l'étude fonctionnelle validée en `0-pre.2.fix.3` avec deux axes manquants : adversaires pilotés/bots et architecture Web/identité/hébergement multi-jeux.
+
+## Bot / pseudo-IA
+
+L'étude couvre :
+
+- logique simple ;
+- recherche/pathfinding ;
+- modèles entraînés éventuels ;
+- bot local ;
+- bot serveur ;
+- difficulté ;
+- remplacement de joueur ;
+- bots de tests/charge ;
+- réutilisation des semantic actions ;
+- séparation entre moteur d'exécution et stratégie propre au jeu.
+
+Aucune dépendance ML n'est réservée comme obligatoire.
+
+## Web / identité / hébergement
+
+L'étude couvre :
+
+- identité canonique `PlayerId` ;
+- anonymous account ;
+- credentials propres ;
+- OAuth/OIDC ;
+- Google/Apple ;
+- Play Games/Game Center/Steam comme identities liées ;
+- account linking/merge ;
+- sessions/tokens ;
+- portail initial `games.sasedev.com` ;
+- pages/jeux sous portail commun ;
+- migration future d'un jeu vers son propre domaine ;
+- services logiques `www/auth/api/cdn/leaderboard/realtime/admin` ;
+- services spécifiques par jeu ;
+- multi-tenant logique ;
+- modular monolith initial puis séparation motivée par besoin réel ;
+- CORS/origins/OAuth redirects lors de la multiplication des domaines.
+
+## Fichiers nouveaux
+
+- `docs/studies/007-GAME_AI_AND_BOT_EXECUTION_STUDY.md` ;
+- `docs/studies/008-WEB_IDENTITY_AND_GAME_HOSTING_STUDY.md` ;
+- `history/0.2.0/0-pre.2.fix.3.md`.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune gate Cargo/Gradle/smoke n'est requise : aucune implémentation runtime ou configuration de build n'est modifiée.

deltas/0.2.0/0-pre.4.fix.1.md

@@ -0,0 +1,66 @@
+<!-- file: deltas/0.2.0/0-pre.4.fix.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.4.fix.1
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.4`.
+
+Le delta `0-pre.4.md` reste immuable.
+
+## Objet
+
+Recentrer tous les POC plateforme étudiés sur Snake comme jeu-sonde unique.
+
+Le prochain jeu réel pressenti étant un super Snake, cette correction permet aux POC de plateforme de préparer directement ses besoins plutôt que de répartir l'effort entre Reflex et Snake.
+
+## Décision d'étude
+
+Les nouveaux POC plateforme utilisent Snake :
+
+- Tauri Android + Snake ;
+- Web navigateur direct + Snake ;
+- Tauri Desktop + Snake ;
+- builder Android multi-ABI centré sur Snake ;
+- futurs POC Windows/macOS/iOS SDL avec Snake lorsque les environnements sont disponibles.
+
+Reflex reste une référence technique historique pour les briques Tauri/WASM déjà construites, mais n'est plus le jeu principal des futurs POC plateforme.
+
+## Raisons
+
+Snake exerce davantage de besoins utiles pour le futur jeu réel :
+
+- input continu ;
+- clavier/swipe/touch ;
+- grille ;
+- plusieurs entités ;
+- collision/obstacles ;
+- état de jeu plus long ;
+- resize/orientation ;
+- virtual controls éventuels ;
+- future extension multi-snake et multiplayer.
+
+## Fichiers modifiés
+
+- `Cargo.toml` ;
+- `Android/game-reflex-poc/build.gradle` ;
+- `Android/game-snake-poc/build.gradle` ;
+- `README.md` ;
+- `docs/studies/000-README.md` ;
+- `docs/studies/009-PLATFORM_POC_CANDIDATES.md` ;
+- `docs/studies/010-PLATFORM_POC_REUSE_AND_DELTA.md` ;
+- `docs/studies/011-PLATFORM_POC_VALIDATION_MATRIX.md` ;
+- `docs/studies/012-PLATFORM_POC_SEQUENCE.md`.
+
+Tous les fichiers existants modifiés et possédant un en-tête `version` ont été incrémentés.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune implémentation runtime n'est ajoutée.

deltas/0.2.0/0-pre.4.fix.2.md

@@ -0,0 +1,45 @@
+<!-- file: deltas/0.2.0/0-pre.4.fix.2.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.4.fix.2
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.4.fix.1`.
+
+Le delta `0-pre.4.fix.1.md` reste immuable.
+
+## Objet
+
+Correction strictement documentaire de l'alignement du tableau de `docs/studies/011-PLATFORM_POC_VALIDATION_MATRIX.md`.
+
+## Correction
+
+Le tableau est reconstruit selon la convention contrôlée par `scripts/audit_markdown_tables.py` :
+
+- largeur brute constante pour chaque colonne ;
+- padding des lignes de contenu ;
+- ligne séparatrice sans espaces ;
+- nombre de tirets exactement égal à la largeur brute de chaque colonne.
+
+Aucun contenu fonctionnel ou architectural n'est modifié.
+
+## Fichiers modifiés
+
+- `Cargo.toml` ;
+- `Android/game-reflex-poc/build.gradle` ;
+- `Android/game-snake-poc/build.gradle` ;
+- `README.md` ;
+- `docs/studies/011-PLATFORM_POC_VALIDATION_MATRIX.md`.
+
+Tous les fichiers existants modifiés et possédant un en-tête `version` ont été incrémentés.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune gate Cargo, Gradle ou smoke n'est requise.

deltas/0.2.0/0-pre.4.md

@@ -0,0 +1,55 @@
+<!-- file: deltas/0.2.0/0-pre.4.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.4
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.3.fix.1`.
+
+## Objet
+
+Définir les POC plateforme utiles avant toute implémentation de la série suivante.
+
+## Études ajoutées
+
+- candidats POC plateforme ;
+- réutilisation du code existant ;
+- matrice commune de validation ;
+- séquence proposée pour une future série `0.3.x`.
+
+## POC prioritaires étudiés
+
+Première vague candidate :
+
+- Tauri Android + Reflex ;
+- Web navigateur direct + Reflex ;
+- Tauri Desktop + Snake ;
+- builder Android multi-ABI.
+
+Deuxième vague lorsque l'environnement existe :
+
+- Windows SDL natif ;
+- macOS SDL natif ;
+- iOS SDL natif.
+
+Tauri iOS reste conditionnel aux résultats Tauri Android et à l'existence d'un besoin Apple réel.
+
+## Principes
+
+- réutiliser le gameplay existant ;
+- minimiser le code spécifique ;
+- mesurer la duplication ;
+- ne pas extraire prématurément une abstraction avant d'avoir observé au moins un besoin réel ;
+- comparer SDL natif, Web/WASM et Tauri/WebView ;
+- ne pas implémenter les POC dans `0.2.0`.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune gate Cargo/Gradle/smoke n'est requise pour ce delta documentaire.

deltas/0.2.0/0-pre.5.fix.1.md

@@ -0,0 +1,103 @@
+<!-- file: deltas/0.2.0/0-pre.5.fix.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.5.fix.1
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.5`.
+
+Le delta `0-pre.5.md` reste immuable.
+
+## Objet
+
+Préciser la spécification fonctionnelle de Uroburas avant la phase de classification architecturale.
+
+## Contenu embarqué et téléchargé
+
+Le jeu peut embarquer les premières maps solo et leurs assets.
+
+Il doit également permettre le téléchargement et la mise à jour séparée de maps, skins, sons, textures/sprites, rulesets et autres assets.
+
+## Anatomie minimale
+
+Un serpent valide contient au minimum :
+
+1. tête ;
+2. cou ;
+3. une unité de corps ;
+4. queue.
+
+Seul le corps est extensible.
+
+Un effet de rétrécissement ne peut pas réduire un serpent sous quatre unités hors règle de mort explicite.
+
+## Sprites et rotations
+
+La spec précise :
+
+- réutilisation des sprites par rotation lorsque possible ;
+- variantes dédiées pour les virages gauche/droite du corps ;
+- contrat de skin compatible avec cette géométrie ;
+- éditeur Web de skins possible d'abord pour les administrateurs puis, ultérieurement, pour les utilisateurs avec contraintes/modération.
+
+## Première version réelle Uroburas
+
+La priorité fonctionnelle est désormais explicitement :
+
+1. Mode 1 — Challenge ;
+2. Mode 3 — Persistent Battle Royale ;
+3. Mode 2 — PvP Battles.
+
+La première version réelle se concentre sur les moteurs nécessaires au Mode 1 :
+
+- grille/tilemap toroïdale ;
+- obstacles ;
+- items ;
+- vies ;
+- temps ;
+- stages ;
+- caméra ;
+- contrôles ;
+- site Web ;
+- auth ;
+- rewarded ads ;
+- Hall of Fame initial ;
+- échange client/serveur authentifié/versionné/validable ;
+- téléchargement de contenu.
+
+## Contrôles Mobile/Tablet
+
+La première approche privilégie des boutons directionnels affichés à l'écran, équivalents fonctionnels des contrôles clavier Desktop, plutôt qu'un contrôle principal par swipe.
+
+## Rewarded ads
+
+Outre la continuation après perte de toutes les vies, une rewarded ad peut être proposée pendant la transition de stage pour appliquer un bonus volontaire, par exemple doubler les points gagnés sur le stage terminé.
+
+## Combat avancé
+
+Feu, glace, poison, téléporteurs et protections restent décrits comme direction fonctionnelle, mais sont explicitement hors scope de la première version réelle centrée sur le Mode 1.
+
+## Fichiers modifiés
+
+- `Cargo.toml` ;
+- `Android/game-reflex-poc/build.gradle` ;
+- `Android/game-snake-poc/build.gradle` ;
+- `README.md` ;
+- `docs/studies/013-UROBURAS_FUNCTIONAL_SPEC.md` ;
+- `docs/studies/014-UROBURAS_MODES_AND_SESSION_RULES.md` ;
+- `docs/studies/015-UROBURAS_MAP_ASSET_AND_UGC_SPEC.md` ;
+- `docs/studies/016-UROBURAS_COMBAT_ITEM_EFFECT_SPEC.md` ;
+- `docs/studies/017-UROBURAS_SCORE_RESPAWN_AND_HALL_OF_FAME.md`.
+
+Tous les fichiers existants modifiés et possédant un en-tête `version` ont été incrémentés.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune gate Cargo, Gradle ou smoke n'est requise pour ce fix documentaire.

deltas/0.2.0/0-pre.5.md

@@ -0,0 +1,43 @@
+<!-- file: deltas/0.2.0/0-pre.5.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.5
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.4.fix.2`.
+
+## Objet
+
+Décrire fonctionnellement le prochain jeu réel, `Uroburas`, avant reclassification architecturale.
+
+## Contenu
+
+- client léger en contenu avec téléchargement de maps/assets ;
+- Challenge solo/offline-capable ;
+- PvP Battles authentifié avec maps, joueurs présélectionnés/aléatoires, équipes, bots et spectator ;
+- Persistent Battle Royale authentifié ;
+- règles spécialisables par map ;
+- armes/protections avec effets différents tête/corps/queue ;
+- score, vies, rewarded continue/rejoin ;
+- éditeur de maps, skins/UGC ;
+- Hall of Fame ;
+- replay/streaming/video régénérée côté serveur.
+
+## Règle de build
+
+Les scripts Python restent autorisés pour audit et validation complémentaire mais ne pilotent pas les builds. Les builds utilisent les outils natifs appropriés, notamment Cargo, Gradle et Tauri CLI. Builds, tests unitaires/intégration et smoke tests restent exécutés côté utilisateur.
+
+## Classification
+
+Le mapping vers engine, capability, game-system, Uroburas-specific, platform, provider, server et tooling est réservé à la prerelease suivante.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune gate Cargo/Gradle/smoke n'est requise pour cette prerelease documentaire.

deltas/0.2.0/0-pre.6.fix.1.md

@@ -0,0 +1,84 @@
+<!-- file: deltas/0.2.0/0-pre.6.fix.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.6.fix.1
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.6`.
+
+Le delta `0-pre.6.md` reste immuable.
+
+## Objet
+
+Compléter la classification de `0-pre.6` avec la stratégie réseau/asset delivery récente et formaliser la discipline de dimensionnement des versions/sessions inspirée du workflow KSP.
+
+## Workflow de version
+
+`0-pre.1` devient obligatoirement la tranche de cadrage :
+
+- audit de la base ;
+- brainstorming/recherche de requirements ;
+- sizing ;
+- planification ;
+- dépendances ;
+- validations ;
+- découpage prévisionnel.
+
+Une version doit être dimensionnée pour être entièrement terminée dans une seule session.
+
+Les tranches `pre/alpha/beta/rc` visent généralement des deltas de 15 à 30 minutes. Une tranche trop lourde est scindée avant exécution ; une tranche trop petite peut être regroupée avec une tranche cohérente.
+
+La dernière tranche avant publication consolide validations, documentation durable, CHANGELOG, ROADMAP et prompt suivant. La release stable reste autant que possible mécanique.
+
+## Réseau et asset delivery
+
+La direction étudiée devient :
+
+- Actix Web pour Web/API ;
+- asset delivery auto-hébergé ;
+- HTTP/2 baseline ;
+- HTTP/3/QUIC pour les assets lorsque disponible ;
+- H2/H3 sur un même hostname de préférence ;
+- séparation logique initiale, séparation physique progressive ;
+- WebSocket/tokio-tungstenite comme baseline realtime ;
+- WebTransport/QUIC comme candidat à benchmarker ;
+- fallback transport ;
+- simulation indépendante du transport ;
+- gRPC/Tonic réservé principalement aux frontières server-to-server justifiées.
+
+## Classification
+
+La capability réseau est décomposée conceptuellement en :
+
+```text
+HTTP client
+realtime transport API
+WebSocket implementation
+WebTransport implementation
+wire protocol
+session protocol
+reconnect/resync
+```
+
+Les crates Uroburas ne dépendent pas directement d'un transport concret.
+
+## Reste de la 0.2.0
+
+Après validation de cette tranche :
+
+1. consolider les études acceptées dans `docs/architecture/` et les règles durables ;
+2. réconcilier ROADMAP et décisions finales ;
+3. produire la tranche de clôture documentaire ;
+4. préparer le prompt de la session `0.3.x` consacrée aux POC ;
+5. passer en RC puis stable sans rouvrir le scope.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune gate Cargo, Gradle ou smoke n'est requise : cette correction reste documentaire.

deltas/0.2.0/0-pre.6.md

@@ -0,0 +1,75 @@
+<!-- file: deltas/0.2.0/0-pre.6.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.6
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.5.fix.1`.
+
+## Objet
+
+Classifier les fonctionnalités Uroburas avant toute implémentation afin d'éviter un monolithe dans les futures crates multiplateformes du jeu.
+
+## Classification
+
+Les responsabilités sont réparties entre :
+
+- engine kernel ;
+- technical capabilities ;
+- game-systems réutilisables ;
+- gameplay Uroburas-specific ;
+- services serveur ;
+- providers ;
+- platform adapters ;
+- tooling.
+
+## Décomposition candidate
+
+L'étude propose des familles de crates pour :
+
+- capabilities ;
+- game-systems ;
+- Uroburas ;
+- apps ;
+- servers ;
+- providers ;
+- tools.
+
+Aucune création massive de crates n'est imposée : l'extraction doit rester motivée par une frontière et une API réelles.
+
+## Stack serveur de référence
+
+Direction étudiée :
+
+- Tokio ;
+- Actix Web ;
+- Maud ;
+- tokio-tungstenite pour le realtime public ;
+- tonic/gRPC conditionnel pour server-to-server ;
+- Fluent/fluent-bundle ;
+- Lettre.
+
+Le client public reste orienté `HTTPS + WebSocket`.
+
+## Ordre d'implémentation
+
+Priorité :
+
+1. fondations réutilisables ;
+2. game-systems du Mode 1 ;
+3. Uroburas Challenge ;
+4. services Web V1 ;
+5. intégration client/server Mode 1 ;
+6. Mode 3 ;
+7. Mode 2.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune gate Cargo/Gradle/smoke n'est requise : ce delta reste documentaire.

deltas/0.2.0/0-pre.7.md

@@ -0,0 +1,82 @@
+<!-- file: deltas/0.2.0/0-pre.7.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.7
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.6.fix.1`.
+
+Cette base est utilisée comme état de travail. Aucune entrée d'historique ne prétend que `0-pre.6.fix.1` a déjà passé une validation utilisateur non fournie.
+
+## Objet
+
+Promouvoir les décisions retenues des études `0.2.0` vers des documents durables d'architecture et de règles.
+
+## Architecture consolidée
+
+Documents ajoutés :
+
+- architecture modulaire et ownership ;
+- architecture réseau/serveur ;
+- architecture cible Uroburas ;
+- architecture des POC plateforme/réseau.
+
+Les études restent comme justification et historique de conception ; les nouveaux documents portent les orientations durables.
+
+## Règles consolidées
+
+Deux règles durables sont ajoutées :
+
+- cadrage des versions/sessions/prompts ;
+- portabilité et auto-hébergement serveur.
+
+La cible opérationnelle préférée est Debian Stable, actuellement Debian 13 `trixie`, sans dépendance métier à cette version.
+
+Les choix futurs HAProxy/nginx/HTTP3 edge/storage restent explicitement hors gel `0.2.0`.
+
+## Réseau durable
+
+- Actix Web reste la référence Web/API ;
+- Maud reste la référence HTML server-side ;
+- Fluent/fluent-bundle porte la localisation ;
+- Lettre porte l'email transactionnel ;
+- WebSocket/tokio-tungstenite est la baseline realtime ;
+- WebTransport/QUIC reste un candidat POC ;
+- gRPC/Tonic est conditionnel aux frontières server-to-server ;
+- asset delivery reste auto-hébergé et compatible H2/H3 selon disponibilité.
+
+## Workflow durable
+
+`pre.1` devient la tranche obligatoire de cadrage.
+
+Une version est dimensionnée pour tenir dans une session.
+
+Les tranches visent normalement 15 à 30 minutes et restent fonctionnellement complètes.
+
+La fin de version consolide CHANGELOG, ROADMAP et le prompt suivant ; la stable reste mécanique.
+
+## ROADMAP
+
+Les lignes de scope `0.2.0` ne sont pas marquées comme complètes dans ce delta avant revue humaine de la consolidation.
+
+## Suite attendue
+
+Après validation de `0-pre.7` :
+
+1. audit documentaire global ;
+2. réconciliation finale studies/architecture/rules/ROADMAP ;
+3. CHANGELOG de candidate ;
+4. prompt de session `0.3.x` ;
+5. RC documentaire ;
+6. release stable mécanique.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune gate Cargo/Gradle/smoke n'est requise : `0.2.0` reste strictement documentaire hors métadonnées de version.

deltas/0.2.0/0-pre.8.fix.1.md

@@ -0,0 +1,40 @@
+<!-- file: deltas/0.2.0/0-pre.8.fix.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.8.fix.1
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.8`.
+
+Le delta `0-pre.8.md` reste immuable.
+
+## Objet
+
+Renforcer le prompt de démarrage `0.3.x` afin qu'il fournisse un véritable plan de session exploitable, inspiré du modèle KSP mais plus compact.
+
+## Correction
+
+Le prompt ajoute :
+
+- mission bornée de `0.3.0` ;
+- cadrage `0-pre.1` détaillé ;
+- forecast souple tranche par tranche pour `0.3.0` ;
+- objectifs et critères des phases pre/alpha/beta/rc candidates ;
+- règles de fusion/scission/report ;
+- forecast initial `0.3.0` à `0.3.6` ;
+- dépendances entre versions ;
+- ordre de préférence des premiers POC ;
+- critères de fin explicites.
+
+Le forecast n'est pas contractuel : `pre.1` doit le corriger immédiatement si le sizing réel le contredit.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune gate Cargo/Gradle/smoke n'est requise : ce fix est documentaire hors métadonnées de version.

deltas/0.2.0/0-pre.8.md

@@ -0,0 +1,58 @@
+<!-- file: deltas/0.2.0/0-pre.8.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-0-pre.8
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.7`.
+
+`0-pre.7` a été validée par revue humaine et audits projet.
+
+## Objet
+
+Clore la phase de conception `0.2.0` avant RC.
+
+## Réconciliation finale
+
+Cette tranche :
+
+- ferme les lignes durables `0.2.0` du ROADMAP ;
+- ajoute le résumé `CHANGELOG` de `0.2.0` ;
+- ajoute une baseline architecturale consolidée ;
+- enregistre l'historique validé de `0-pre.7` ;
+- prépare le prompt de session `0.3.x`.
+
+## Prompt 0.3.x
+
+Le prompt fixe :
+
+- `pre.1` comme cadrage obligatoire ;
+- Snake comme jeu-sonde ;
+- POC Tauri Android/Web/Tauri Desktop/Android multi-ABI ;
+- POC WebSocket vs WebTransport/QUIC ;
+- builds via outils natifs ;
+- utilisateur responsable des builds/tests/smoke ;
+- Debian Stable comme cible opérationnelle préférée ;
+- Uroburas réservé à `0.4.x`.
+
+## Gel
+
+Après validation de `0-pre.8`, le scope documentaire `0.2.0` est considéré complet.
+
+La RC suivante est une candidate de publication :
+
+- aucune nouvelle fonctionnalité ;
+- aucune nouvelle orientation architecturale ;
+- corrections seulement si nécessaires ;
+- revue humaine finale.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune gate Cargo, Gradle ou smoke n'est requise : `0.2.0` reste documentaire hors métadonnées de version.

deltas/0.2.0/3-rc.1.md

@@ -0,0 +1,46 @@
+<!-- file: deltas/0.2.0/3-rc.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0-3-rc.1
+
+## Base
+
+Base déclarée : `0.2.0-0-pre.8.fix.1`.
+
+Cette base a été validée par revue humaine et audits projet.
+
+## Objet
+
+Créer la candidate de publication `0.2.0`.
+
+## Gel
+
+Le scope `0.2.0` est gelé.
+
+Cette RC n'ajoute :
+
+- aucune nouvelle fonctionnalité ;
+- aucune nouvelle orientation architecturale ;
+- aucune nouvelle capability ;
+- aucun nouveau POC.
+
+Elle consolide uniquement :
+
+- métadonnées de version ;
+- CHANGELOG RC ;
+- historique de la dernière prerelease validée ;
+- checklist de revue RC.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune gate Cargo, Gradle ou smoke n'est requise : la version reste documentaire hors métadonnées.
+
+## Après validation
+
+Si cette RC est validée sans correction sémantique, la release `0.2.0` doit être mécanique.

deltas/0.2.0/rel.001.md

@@ -0,0 +1,42 @@
+<!-- file: deltas/0.2.0/rel.001.md -->
+<!-- version: 1 -->
+
+# Delta 0.2.0 — release stable
+
+## Base
+
+Base validée : `0.2.0-3-rc.1`.
+
+## Objet
+
+Promouvoir mécaniquement la candidate validée vers `0.2.0`.
+
+## Changements
+
+La release stable modifie uniquement :
+
+- la version workspace ;
+- les métadonnées Android correspondantes ;
+- la version affichée dans le README ;
+- l'en-tête CHANGELOG de candidate vers stable ;
+- l'historique de validation de la RC.
+
+Aucun nouveau scope fonctionnel, architectural ou documentaire n'est introduit.
+
+## Validation
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucune gate Cargo, Gradle ou smoke supplémentaire n'est requise pour cette promotion documentaire/métadonnée.
+
+## Publication
+
+Après validation :
+
+- commit de release ;
+- tag stable `v0.2.0` ;
+- ouverture de la session `0.3.0` à partir de `prompts/002-V0_3_X_START_PROMPT.md`.

deltas/0.3.0/0-pre.1.fix.1.md

@@ -0,0 +1,85 @@
+<!-- file: deltas/0.3.0/0-pre.1.fix.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0-0-pre.1.fix.1
+
+## Base
+
+Base requise : `0.3.0-0-pre.1`.
+
+Ce correctif reste dans la responsabilité de cadrage de `0-pre.1`. Il ne modifie aucun gameplay, runtime, frontend ou packaging.
+
+## Objet
+
+Corriger deux omissions du cadrage initial :
+
+- créer le plan vivant de `0.3.0` sous `docs/plans/`, avec le découpage prévisionnel souple de toute la progression de la version ;
+- formaliser les règles associées, notamment la relation plan/ROADMAP/deltas, la cible d'au moins une version complète par session et le traitement des archives fournies depuis un tag.
+
+## Version
+
+La version workspace passe de `0.3.0-0-pre.1` à `0.3.0-0-pre.1.fix.1`.
+
+## Plan de version
+
+Ajout de :
+
+- `docs/plans/000-README.md` ;
+- `docs/plans/001-V0_3_0_WEB_SNAKE_POC_PLAN.md`.
+
+Le plan conserve le scope et les décisions du cadrage, puis suit une trajectoire souple : baseline Snake portable, adaptation WASM, frontend Web/Vite, intégration E2E, correction/extraction conditionnelle, beta, RC et stable.
+
+La numérotation est prévisionnelle. Les tranches peuvent être scindées, fusionnées ou décalées en fonction des résultats réels sans forcer une fermeture artificielle.
+
+## Règles ajoutées ou précisées
+
+- `0-pre.1` crée ou révise obligatoirement le plan actif de la version sous `docs/plans/` ;
+- le plan porte le découpage prévisionnel fin, `ROADMAP.md` reste macroscopique et les deltas enregistrent le livré réel ;
+- une session de développement est planifiée pour livrer au minimum une version concrète complète ; une prerelease est une tranche interne, pas une cible normale de fin de session ;
+- lorsqu'une archive est fournie comme téléchargement d'un tag du dépôt, elle est la baseline autoritaire de ce tag ; l'absence de `.git` est normale et n'est ni une anomalie ni une validation manquante ;
+- les contrôles Git nécessitant `.git` ne s'appliquent qu'à un checkout local effectivement fourni.
+
+Le prompt `002-V0_3_X_START_PROMPT.md` est aligné sur ces règles : il ne demande plus de vérifier un état Git inexistant dans une archive taggée et exige le plan actif dans le résultat de `pre.1`.
+
+## Fichiers ajoutés
+
+- `docs/plans/000-README.md` ;
+- `docs/plans/001-V0_3_0_WEB_SNAKE_POC_PLAN.md` ;
+- `deltas/0.3.0/0-pre.1.fix.1.md`.
+
+## Fichiers modifiés
+
+- `Cargo.toml` ;
+- `README.md` ;
+- `docs/000-README.md` ;
+- `docs/rules/FILE_CONTRACTS.md` ;
+- `docs/rules/RULES_DOCUMENTATION.md` ;
+- `docs/rules/RULES_SESSION_PLANNING.md` ;
+- `docs/rules/VERSION_WORKFLOW.md` ;
+- `docs/rules/RULES_COMMANDS.md` ;
+- `prompts/002-V0_3_X_START_PROMPT.md`.
+
+## Suppressions
+
+Aucune.
+
+## Validations applicables
+
+Ce fix modifie uniquement le manifest de version et la documentation/règles. Les audits statiques sont exécutés lors de la préparation du delta.
+
+Validation utilisateur demandée :
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+
+cargo fmt --all -- --check
+cargo check --workspace
+```
+
+Clippy/tests ne sont pas rendus nécessaires par ce fix documentaire lui-même ; ils restent ceux prévus par la progression de `0.3.0`.
+
+## Suite
+
+Après validation de ce fix, poursuivre `0.3.0` selon `docs/plans/001-V0_3_0_WEB_SNAKE_POC_PLAN.md`, en commençant par `0-pre.2` et en visant la fermeture complète de `0.3.0` dans la session plutôt qu'un arrêt planifié sur une prerelease.

deltas/0.3.0/0-pre.1.fix.2.md

@@ -0,0 +1,94 @@
+<!-- file: deltas/0.3.0/0-pre.1.fix.2.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0-0-pre.1.fix.2
+
+## Base
+
+Base requise : `0.3.0-0-pre.1.fix.1`.
+
+Ce correctif reste dans la responsabilité de cadrage de `0-pre.1`. Il ne modifie aucun gameplay, runtime, frontend ou packaging.
+
+## Objet
+
+Compléter le plan `0.3.0` sur deux responsabilités qui doivent être visibles dès le cadrage :
+
+- le POC navigateur doit posséder un véritable shell Web HTML/Vite/TypeScript autour du Canvas/WASM, avec Bootstrap 5 comme baseline de présentation du premier POC Snake ;
+- la prévision de version doit montrer explicitement la tranche finale de consolidation documentaire et de transmission avant RC/stable, au lieu de laisser cette responsabilité seulement implicite dans les règles générales.
+
+## Version
+
+La version workspace passe de `0.3.0-0-pre.1.fix.1` à `0.3.0-0-pre.1.fix.2`.
+
+## Frontend Web
+
+Le plan retient désormais explicitement pour `0-pre.4` :
+
+- Vite/TypeScript comme host frontend ;
+- un document HTML responsive ;
+- Bootstrap 5 pour le layout, les états UI et les contrôles tactiles ;
+- un Canvas dédié au rendu du jeu ;
+- clavier et contrôles directionnels tactiles ;
+- séparation stricte : Bootstrap/DOM restent côté frontend, le gameplay et l'état du jeu restent dans Rust/WASM.
+
+La règle durable ne rend pas Bootstrap obligatoire pour tous les futurs hosts Web : elle impose la séparation shell Web / Canvas-WASM / gameplay. Bootstrap 5 est la décision concrète du POC `0.3.0`.
+
+## Consolidation de fin de version
+
+Le forecast `0.3.0` ajoute `2-beta.2` comme repère prévisionnel de consolidation :
+
+- réconciliation de la documentation durable et du plan actif ;
+- mise à jour de `CHANGELOG.md` ;
+- mise à jour de `ROADMAP.md` ;
+- mise à jour de l'historique applicable ;
+- vérification des deltas réellement livrés ;
+- préparation et vérification du prompt de la version/session suivante.
+
+Le numéro reste souple : des fixes ou une beta supplémentaire peuvent le décaler. La responsabilité, elle, ne doit pas disparaître du plan.
+
+La documentation fonctionnelle reste mise à jour au fil des tranches concernées ; cette consolidation finale sert à fermer la cohérence transversale et la transmission de session.
+
+## Règles précisées
+
+- `SESSION-009` exige que le forecast créé en `0-pre.1` rende explicitement visible une tranche de consolidation avant la candidate finale ;
+- `GAME-PLATFORM-020` fixe la séparation durable du host Web : shell HTML/CSS/TypeScript autour du Canvas/WASM, sans fuite du framework de présentation dans gameplay/WASM ; Bootstrap 5 est la baseline du premier POC Snake.
+
+Le prompt `002-V0_3_X_START_PROMPT.md` est aligné sur les décisions déjà prises par `pre.1` : Web direct en premier host, adaptation WASM dédiée, shell Bootstrap 5 et tranche `2-beta.2` de consolidation/transmission.
+
+## Fichiers ajoutés
+
+- `deltas/0.3.0/0-pre.1.fix.2.md`.
+
+## Fichiers modifiés
+
+- `Cargo.toml` ;
+- `README.md` ;
+- `docs/plans/001-V0_3_0_WEB_SNAKE_POC_PLAN.md` ;
+- `docs/rules/RULES_PROJECT.md` ;
+- `docs/rules/RULES_SESSION_PLANNING.md` ;
+- `prompts/002-V0_3_X_START_PROMPT.md`.
+
+## Suppressions
+
+Aucune.
+
+## Validations applicables
+
+Ce fix modifie uniquement la version workspace et le cadrage documentaire/normatif. Les audits statiques sont exécutés lors de la préparation du delta.
+
+Validation utilisateur demandée :
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+
+cargo fmt --all -- --check
+cargo check --workspace
+```
+
+Aucun build Web n'est demandé par ce fix : Bootstrap 5 et le frontend Snake seront introduits seulement dans leur tranche d'implémentation.
+
+## Suite
+
+Après validation de ce fix, poursuivre `0.3.0` avec `0-pre.2` selon le plan actif. La session reste planifiée jusqu'à la stable `0.3.0`, avec consolidation documentaire/transmission explicitement réservée avant RC.

deltas/0.3.0/0-pre.1.md

@@ -0,0 +1,157 @@
+<!-- file: deltas/0.3.0/0-pre.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0-0-pre.1
+
+## Base
+
+Base déclarée : `0.2.0`.
+
+L'archive de base a été inspectée avant modification. Sa version workspace est `0.2.0`. L'archive ne contient pas `.git`, donc le tag réel et la propreté Git ne peuvent pas être vérifiés dans l'environnement de génération.
+
+## Objet
+
+Ouvrir `0.3.0` par le cadrage obligatoire : audit réel de la baseline, revue des règles, requirements Snake, graphe de dépendances, choix du premier POC, sizing corrigé et préparation des validations.
+
+Aucun gameplay, runtime SDL, Java/JNI, Tauri ou frontend existant n'est modifié dans cette tranche.
+
+## Version
+
+La version workspace passe de :
+
+```text
+0.2.0
+```
+
+à :
+
+```text
+0.3.0-0-pre.1
+```
+
+Les métadonnées Android restent à `0.2.0` dans cette tranche, car le chemin Android natif n'est ni modifié ni construit par le premier POC Web. Elles seront réévaluées dans la version qui réouvre effectivement ce produit Android.
+
+## Audit de baseline
+
+Les audits statiques officiels ont été exécutés avant modification et étaient propres :
+
+```text
+General Rust rule audit: clean
+Rust export completeness audit: 0 candidate(s)
+games.sasedev workspace audit: clean
+Markdown table audit: clean (4 table(s), 158 file(s))
+Distribution layout audit: clean (19 required path(s), 1 forbidden path(s) absent)
+```
+
+La revue manuelle a néanmoins détecté :
+
+- README encore positionné sur `0.1.0` stable / `0.2.0` candidate ;
+- quatre lignes `( )` sous la stable `0.2.0` dans ROADMAP, en violation de `DOC-RMAP-010` ;
+- la gate `audit_rust_workspace_rules.py` qui créait un cache Python `.pyc` pendant son exécution, alors qu’un audit doit rester en lecture seule ;
+- `CMD-RC-001` encore spécifique à `0.1.0` ;
+- contradiction entre `CMD-BUILD-002` (interdiction globale) et `CMD-BUILD-004` (remplacement progressif en `0.3.x`), alors que deux orchestrateurs Python historiques existent encore ;
+- `CMD-WEB-003` décrivant sans contexte le build Python Tauri/WASM historique ;
+- dépendances `engine-v1-platform-api` déclarées mais non utilisées par les crates de jeu ;
+- `RuntimeProvenance` défini mais non branché aux launchers ;
+- `game-assets-lib` encore sans consommateur runtime ;
+- deux orchestrateurs Python de build historiques à ne pas réutiliser dans les nouveaux POC.
+
+Les détails et le graphe complet sont documentés dans `docs/studies/023-V0_3_0_PLATFORM_POC_AUDIT.md`.
+
+## Corrections de règles et hygiène
+
+Cette tranche :
+
+- corrige le README de version ;
+- ferme correctement le scope `0.2.0` dans ROADMAP ;
+- distingue ce qui a été livré de ce qui est reporté ;
+- rend `CMD-RC-001` générique à la version courante ;
+- rend `CMD-BUILD-002` cohérente avec la migration `0.3.x` : les deux orchestrateurs Python historiques sont gelés jusqu’à réactivation de leur chemin, mais aucun nouveau chemin ne peut les reprendre ;
+- qualifie explicitement `scripts/build_reflex_tauri_wasm.py` de mécanisme historique non réutilisable comme orchestration `0.3.x` ;
+- renforce `audit_project_workspace_rules.py` pour détecter le scope `( )` restant sous une version stable présente dans CHANGELOG ;
+- fait exécuter les sous-audits de `audit_rust_workspace_rules.py` avec l’interpréteur courant et `-B`, afin que la gate standard reste effectivement en lecture seule malgré l’import effectué dans l’audit de complétude des exports.
+
+## Premier POC retenu
+
+Le premier host de `0.3.0` devient :
+
+```text
+Web navigateur direct + Snake
+```
+
+Tauri Android est reporté au second host, actuellement prévu en `0.3.1`.
+
+Le but est de valider d'abord la frontière Web/WASM et les capabilities directement observables sans cumuler simultanément la généralisation Snake/WASM et la complexité d'un host mobile Tauri.
+
+## Forecast corrigé
+
+```text
+0-pre.1  audit / règles / requirements / sizing
+0-pre.2  Snake portability baseline
+0-pre.3  adapter Snake WASM + build natif Web
+0-pre.4  navigateur direct end-to-end
+0-pre.5  seulement si un défaut réel est observé
+2-beta.1 validation large
+3-rc.1   candidate gelée
+0.3.0    release mécanique
+```
+
+Aucune alpha n'est créée par cérémonial. Elle reste possible si le volume réel de stabilisation le justifie.
+
+## Scope exclu de 0.3.0
+
+- Tauri Android ;
+- Tauri Desktop Snake ;
+- Android multi-ABI natif ;
+- réseau realtime ;
+- WebTransport/QUIC ;
+- Uroburas ;
+- ads, billing, auth et leaderboard ;
+- ECS ou nouveau moteur.
+
+## Suppressions
+
+Aucune suppression de fichier appartenant à la baseline `0.2.0` n'est nécessaire.
+
+## Validations exécutées dans l'environnement de génération
+
+Après constitution de l'état livré, les audits statiques suivants doivent être réexécutés et leur résultat est enregistré avant packaging :
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucun build/test/smoke n'est exécuté par le générateur, conformément à `CMD-GEN-007` et `CMD-BUILD-005`.
+
+## Validation utilisateur demandée
+
+Cette tranche ne modifie aucun source Rust/Java/TypeScript ni aucune configuration runtime. Elle ouvre toutefois une nouvelle version `0.3.0` et modifie le manifest workspace ; la gate utilisateur retient donc les audits statiques puis une gate Cargo workspace complète, conformément à la discipline des frontières de version :
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+
+cargo fmt --all -- --check
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+cargo test --workspace --all-targets --all-features
+```
+
+Aucun build de distribution, smoke Desktop, Tauri ou Android n'est requis par `pre.1`, car aucun runtime ni packaging de ces hosts n'est modifié.
+
+La revue humaine doit confirmer :
+
+- le choix Web direct comme premier POC ;
+- le scope corrigé de `0.3.0` ;
+- le report de Tauri Android vers le second host ;
+- le sizing `pre.2` à `pre.4` ;
+- la fermeture correcte des lignes historiques `0.2.0`.
+
+## Suite après validation
+
+Si cette gate est propre et le cadrage accepté, passer automatiquement à `0.3.0-0-pre.2`.
+
+`pre.2` doit rester une tranche bornée de portabilité Snake et de nettoyage de dépendances ; elle ne doit pas commencer le frontend Web complet.

deltas/0.3.0/0-pre.2.md

@@ -0,0 +1,102 @@
+<!-- file: deltas/0.3.0/0-pre.2.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0-0-pre.2
+
+## Base
+
+Base requise : `0.3.0-0-pre.1.fix.2`.
+
+Les validations utilisateur de `0-pre.1.fix.1` et `0-pre.1.fix.2` sont consignées sous `history/0.3.0/` conformément au workflow documentaire.
+
+## Objet
+
+Fermer la baseline Snake portable avant l'introduction de l'adapter WASM :
+
+- retirer des crates de gameplay les dépendances plateforme déclarées mais inutilisées ;
+- confirmer que le gameplay Snake ne consomme que les contrats moteur indépendants de la plateforme ;
+- documenter le contrat minimal que le futur host Web devra adapter sans introduire encore de code WASM ou frontend.
+
+## Version
+
+La version workspace passe de `0.3.0-0-pre.1.fix.2` à `0.3.0-0-pre.2`.
+
+## Nettoyage des dépendances
+
+`engine-v1-platform-api` est retiré de :
+
+- `game-snake-poc` ;
+- `game-reflex-poc`.
+
+Ces deux crates n'utilisent aucun symbole de cette dépendance. Les launchers et adapters qui utilisent réellement des capacités plateforme conservent leur dépendance.
+
+Ce nettoyage ne déplace aucune responsabilité et ne change aucun comportement de gameplay.
+
+## Contrat Snake portable
+
+La baseline confirmée pour Snake est :
+
+- état et update via `EngineGame` ;
+- entrée via `InputState` ;
+- actions de gameplay utilisées : `Left`, `Right`, `Up`, `Down` ;
+- rendu abstrait via `EngineScene` ;
+- aucune dépendance SDL3, Web/DOM/Canvas ou `engine-v1-platform-api` dans `game-snake-poc`.
+
+Le host reste responsable de traduire ses périphériques ou widgets en actions logiques. Le futur adapter WASM `0-pre.3` doit réutiliser cette frontière sans créer un modèle Web parallèle.
+
+## Historique des validations précédentes
+
+Ajout de :
+
+- `history/0.3.0/0-pre.1.fix.1.md` ;
+- `history/0.3.0/0-pre.1.fix.2.md`.
+
+Ces fichiers enregistrent uniquement les résultats effectivement fournis par l'utilisateur : audits statiques, `cargo fmt --all -- --check` et `cargo check --workspace`. Aucun Clippy, test ou smoke non exécuté n'est déclaré validé.
+
+## Fichiers ajoutés
+
+- `deltas/0.3.0/0-pre.2.md` ;
+- `history/0.3.0/0-pre.1.fix.1.md` ;
+- `history/0.3.0/0-pre.1.fix.2.md`.
+
+## Fichiers modifiés
+
+- `Cargo.toml` ;
+- `README.md` ;
+- `crates/games/game-reflex-poc/Cargo.toml` ;
+- `crates/games/game-snake-poc/Cargo.toml` ;
+- `docs/architecture/004-INPUT_AND_CONTROLS.md` ;
+- `docs/plans/001-V0_3_0_WEB_SNAKE_POC_PLAN.md`.
+
+## Suppressions
+
+Aucune.
+
+## Validations applicables
+
+Audits statiques de préparation :
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Validation utilisateur demandée :
+
+```bash
+cargo fmt --all -- --check
+cargo check --workspace
+cargo clippy -p game-snake-poc --all-targets --all-features -- -D warnings
+cargo clippy -p game-reflex-poc --all-targets --all-features -- -D warnings
+cargo test -p game-snake-poc
+cargo test -p game-reflex-poc
+cargo tree -p game-snake-poc --edges normal
+cargo tree -p game-reflex-poc --edges normal
+```
+
+Les deux `cargo tree` doivent confirmer que les crates de gameplay ne tirent plus `engine-v1-platform-api`. Aucun smoke Desktop n'est requis : ni `engine-v1-sdl`, ni le mapping SDL, ni le runner Snake ne sont modifiés dans cette tranche.
+
+## Suite
+
+Après validation de `0-pre.2`, ouvrir `0-pre.3` pour l'adaptation WASM minimale de Snake conformément au plan actif. Aucun frontend Bootstrap/Vite n'est introduit avant `0-pre.4`.

deltas/0.3.0/0-pre.3.md

@@ -0,0 +1,118 @@
+<!-- file: deltas/0.3.0/0-pre.3.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0-0-pre.3
+
+## Base
+
+Base requise : `0.3.0-0-pre.2`.
+
+La validation complète de `0-pre.2` est consignée dans `history/0.3.0/0-pre.2.md`.
+
+## Objet
+
+Introduire l'adapter WASM minimal de Snake avant tout frontend navigateur :
+
+- ajouter `game-snake-poc-wasm` comme crate d'application dédiée ;
+- réutiliser exclusivement `engine-v1-common` et `game-snake-poc` ;
+- exposer à `wasm-bindgen` les directions logiques et la scène portable ;
+- préserver la cadence de simulation en séparant événement d'entrée et `tick()` ;
+- documenter un chemin Cargo + `wasm-bindgen` direct sans orchestrateur Python ;
+- ne pas introduire Vite, Bootstrap, DOM, Tauri ou SDL3 dans cette tranche.
+
+## Version
+
+La version workspace passe de `0.3.0-0-pre.2` à `0.3.0-0-pre.3`.
+
+## Adapter Snake WASM
+
+La nouvelle crate `crates/apps/game-snake-poc-wasm` contient une façade `lib.rs` et un runtime propriétaire séparé.
+
+`SnakeWasmGame` possède :
+
+- un `SnakeState` issu de la crate de gameplay ;
+- un `FixedStepRunner` à pas déterministe de 16 ms ;
+- un `InputState` en attente pour la prochaine update.
+
+Les appels `left()`, `right()`, `up()` et `down()` ne font pas avancer la simulation. Ils remplacent la direction logique en attente. `tick()` consomme ensuite cette entrée une fois, la remet à zéro et avance le runner d'une update. La cadence reste ainsi sous la responsabilité du futur host navigateur.
+
+L'API expose également le score, la longueur, la couleur de fond et les rectangles normalisés de l'`EngineScene`. Le futur frontend `0-pre.4` peut donc dessiner le Canvas sans accéder à la structure interne de Snake.
+
+## Frontières conservées
+
+`game-snake-poc-wasm` ne dépend pas de :
+
+- `engine-v1-platform-api` ;
+- `engine-v1-sdl` ;
+- Tauri ;
+- DOM/Canvas Rust ;
+- code frontend TypeScript.
+
+La duplication limitée des getters de scène avec `game-reflex-poc-wasm` est volontairement conservée à ce stade. Une abstraction commune ne sera extraite que si les POC suivants démontrent un besoin partagé suffisamment stable.
+
+## Documentation et audits
+
+L'architecture du workspace mentionne désormais l'adapter Snake WASM et le contrat d'entrée précise la file directionnelle consommée par `tick()`.
+
+L'audit de distribution exige maintenant `crates/apps/game-snake-poc-wasm/Cargo.toml`, portant le nombre de chemins requis de 19 à 20.
+
+Le plan actif est réconcilié avec la livraison réelle de `0-pre.3`. `docs/development/009-SNAKE_WEB_WASM_BUILD.md` documente le build natif Cargo + `wasm-bindgen`, avec tous les artefacts générés sous `../builds/sasedev-games/`.
+
+## Historique
+
+Ajout de `history/0.3.0/0-pre.2.md` avec les résultats réellement fournis par l'utilisateur : audits, formatage, check workspace, Clippy workspace strict, tests Snake/Reflex et graphes de dépendances.
+
+## Fichiers ajoutés
+
+- `crates/apps/game-snake-poc-wasm/Cargo.toml` ;
+- `crates/apps/game-snake-poc-wasm/src/lib.rs` ;
+- `crates/apps/game-snake-poc-wasm/src/runtime.rs` ;
+- `crates/apps/game-snake-poc-wasm/unit_tests/runtime.rs` ;
+- `deltas/0.3.0/0-pre.3.md` ;
+- `docs/development/009-SNAKE_WEB_WASM_BUILD.md` ;
+- `history/0.3.0/0-pre.2.md`.
+
+## Fichiers modifiés
+
+- `Cargo.toml` ;
+- `README.md` ;
+- `docs/architecture/001-WORKSPACE_ARCHITECTURE.md` ;
+- `docs/000-README.md` ;
+- `docs/architecture/004-INPUT_AND_CONTROLS.md` ;
+- `docs/plans/001-V0_3_0_WEB_SNAKE_POC_PLAN.md` ;
+- `scripts/audit_distribution_layout.py`.
+
+## Suppressions
+
+Aucune.
+
+## Validations applicables
+
+Audits statiques de préparation :
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Validation utilisateur demandée :
+
+```bash
+cargo fmt --all
+cargo fmt --all -- --check
+cargo check --workspace
+cargo clippy -p game-snake-poc-wasm --all-targets --all-features -- -D warnings
+cargo test -p game-snake-poc-wasm
+cargo build -p game-snake-poc-wasm --target wasm32-unknown-unknown
+wasm-bindgen ../builds/sasedev-games/target/wasm32-unknown-unknown/debug/game_snake_poc_wasm.wasm --target web --out-dir ../builds/sasedev-games/game-snake-poc-web/wasm --out-name game_snake_poc_wasm
+cargo tree -p game-snake-poc-wasm --edges normal
+```
+
+Le `cargo tree` doit rester limité à `engine-v1-common`, `game-snake-poc`, `wasm-bindgen` et leurs dépendances nécessaires ; aucune dépendance SDL3, Tauri ou `engine-v1-platform-api` ne doit apparaître.
+
+La commande `wasm-bindgen` doit produire les bindings navigateur sans écrire d'artefact généré dans le dépôt. Aucun build Vite/Bootstrap et aucun smoke navigateur ne sont requis dans cette tranche, car le frontend appartient à `0-pre.4`.
+
+## Suite
+
+Après validation de `0-pre.3`, ouvrir `0-pre.4` pour le frontend Web direct Vite/TypeScript, son shell HTML Bootstrap 5, le Canvas et les contrôles clavier/tactiles.

deltas/0.3.0/0-pre.4.fix.1.md

@@ -0,0 +1,56 @@
+<!-- file: deltas/0.3.0/0-pre.4.fix.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0-0-pre.4.fix.1
+
+## Objectif
+
+Fermer les défauts découverts pendant la validation utilisateur de `0-pre.4` sans ouvrir le scope `0-pre.5`.
+
+## Corrigé
+
+- suppression de `compilerOptions.baseUrl`, retiré par TypeScript 7, tout en conservant le mapping `paths` et l'alias Vite `@snake-wasm` ;
+- réintégration de `simplebar` et `resize-observer-polyfill` depuis le template KSP comme dépendances runtime du shell navigateur ;
+- ajout du Sass SimpleBar KSP-derived et activation de `data-simplebar` sur `app-main` ;
+- maintien du header et du footer fixes avec scroll interne de la zone centrale lorsque son contenu dépasse la hauteur disponible ;
+- retrait des contraintes `h-100` internes qui empêchaient le contenu du shell de prendre sa hauteur naturelle ;
+- correction du plateau Snake de `1 / 1` vers `3 / 5`, cohérente avec la grille logique `12 × 20`, afin de conserver des cellules visuellement carrées ;
+- conservation du resize haute densité via `devicePixelRatio` à l'intérieur du ratio CSS corrigé ;
+- correction de la documentation qui classait à tort SimpleBar et le polyfill parmi les dépendances propres à Tauri ;
+- ajout d'une règle durable sur le scroll shell Web et extension de l'audit de distribution au Sass SimpleBar ;
+- consignation sous `history/0.3.0/0-pre.4.md` des validations réussies et de l'échec `TS5102` ayant déclenché ce fix.
+
+## Non modifié
+
+- gameplay Snake ;
+- adapter WASM et cadence `tick()` ;
+- mappings clavier/pointer ;
+- lifecycle complet, assets, logging et provenance prévus pour `0-pre.5` ;
+- route de smoke : `http://127.0.0.1:1434/main.html`.
+
+## Validation demandée
+
+Depuis la racine :
+
+```bash
+cargo fmt --all
+cargo fmt --all -- --check
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android Web deltas history
+python3 scripts/audit_distribution_layout.py
+cargo check --workspace
+cargo clippy -p game-snake-poc-wasm --all-targets --all-features -- -D warnings
+cargo test -p game-snake-poc-wasm
+cargo build -p game-snake-poc-wasm --target wasm32-unknown-unknown
+wasm-bindgen ../builds/sasedev-games/target/wasm32-unknown-unknown/debug/game_snake_poc_wasm.wasm --target web --out-dir ../builds/sasedev-games/game-snake-poc-web/wasm --out-name game_snake_poc_wasm
+cd Web/game-snake-poc
+npm install
+npm run build
+npm run dev
+```
+
+Smoke navigateur sur `http://127.0.0.1:1434/main.html` : vérifier clavier, boutons pointer/tactiles, cellules non déformées, scroll SimpleBar lorsque nécessaire et fixation du header/footer.
+
+## Suite
+
+Après validation du fix, `0-pre.5` peut fermer lifecycle/resize, assets, logging, provenance runtime et non-régression Desktop SDL3 conformément au plan actif.

deltas/0.3.0/0-pre.4.fix.2.md

@@ -0,0 +1,50 @@
+<!-- file: deltas/0.3.0/0-pre.4.fix.2.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0-0-pre.4.fix.2
+
+## Objectif
+
+Fermer les deux erreurs TypeScript découvertes pendant la validation utilisateur de `0-pre.4.fix.1`, sans modifier le gameplay ni ouvrir le scope `0-pre.5`.
+
+## Corrigé
+
+- `tsconfig.json` résout désormais `@snake-wasm` vers `game_snake_poc_wasm.d.ts`, généré par `wasm-bindgen`, afin que TypeScript consomme les types réels du bridge sans déclaration manuelle dupliquée ;
+- `vite.config.ts` conserve séparément l'alias runtime vers `game_snake_poc_wasm.js` ;
+- après validation de `canvas.getContext("2d")`, `game.ts` capture le contexte dans une constante `CanvasRenderingContext2D` non nullable utilisée par le callback de frame ;
+- consignation sous `history/0.3.0/0-pre.4.fix.1.md` de la gate réellement exécutée et des deux erreurs ayant déclenché ce fix ;
+- réconciliation du plan actif avec ce second fix de `0-pre.4`.
+
+## Non modifié
+
+- gameplay Snake ;
+- cadence et API du bridge WASM ;
+- ratio Canvas `3 / 5` ;
+- SimpleBar, header/footer fixes et shell Bootstrap ;
+- mappings clavier/pointer ;
+- lifecycle complet, assets, logging et provenance prévus pour `0-pre.5`.
+
+## Validation demandée
+
+Depuis la racine :
+
+```bash
+cargo fmt --all
+cargo fmt --all -- --check
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android Web deltas history
+python3 scripts/audit_distribution_layout.py
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+cargo test -p game-snake-poc-wasm
+cargo build -p game-snake-poc-wasm --target wasm32-unknown-unknown
+wasm-bindgen ../builds/sasedev-games/target/wasm32-unknown-unknown/debug/game_snake_poc_wasm.wasm --target web --out-dir ../builds/sasedev-games/game-snake-poc-web/wasm --out-name game_snake_poc_wasm
+cargo tree -p game-snake-poc-wasm --edges normal
+(cd Web/game-snake-poc && npm install && npm run build && npm run dev)
+```
+
+Smoke navigateur sur `http://127.0.0.1:1434/main.html` : vérifier chargement WASM, clavier, boutons pointer/tactiles, ratio du plateau et scroll SimpleBar lorsque nécessaire.
+
+## Suite
+
+Après validation du fix, `0-pre.5` peut fermer lifecycle/resize, assets, logging, provenance runtime et non-régression Desktop SDL3 conformément au plan actif.

deltas/0.3.0/0-pre.4.fix.3.md

@@ -0,0 +1,64 @@
+<!-- file: deltas/0.3.0/0-pre.4.fix.3.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0-0-pre.4.fix.3
+
+## Objectif
+
+Aligner le scroll SimpleBar du host Snake Web sur le shell réellement utilisé par les applications Desk KSP après validation réussie du build `0-pre.4.fix.2`.
+
+## Diagnostic
+
+La comparaison avec `ksp-app-*-desk` confirme que le package et le Sass SimpleBar étaient présents, mais que le conteneur n'était pas structuré comme la référence :
+
+- KSP garde `app-main` comme conteneur de hauteur bornée et non scrollable ;
+- un enfant `row h-100` porte la zone centrale ;
+- `data-simplebar` est attaché à `app-content app-scrollable h-100` ;
+- `app-scrollable` et `app-content` ont `height: 100%` / `max-height: 100%` ;
+- `main.ts` importe `resize-observer-polyfill` puis `simplebar` et installe le polyfill global avant l'initialisation de l'application.
+
+Le point d'entrée TypeScript Snake suit déjà ce dernier contrat ; le défaut se situe donc dans la structure HTML/Sass.
+
+## Corrigé
+
+- `data-simplebar` est déplacé de `app-main` vers `app-content app-scrollable h-100` ;
+- ajout du conteneur `row g-0 h-100 flex-nowrap` comme dans le shell KSP ;
+- `app-main` reste borné à la hauteur disponible entre header et footer ;
+- `app-scrollable` et `app-content` portent explicitement `height: 100%` et `max-height: 100%` ;
+- la règle `GAME-PLATFORM-023` pérennise ce contrat lorsque le shell KSP/SimpleBar est réutilisé ;
+- `audit_distribution_layout.py` vérifie statiquement que `data-simplebar` reste sur la zone centrale et que le bootstrap TypeScript/Sass requis est présent ;
+- la documentation frontend et le plan `0.3.0` sont réconciliés ;
+- `history/0.3.0/0-pre.4.fix.2.md` consigne la validation réussie du build et le défaut visuel restant.
+
+## Non modifié
+
+- gameplay Snake ;
+- bridge WASM et cadence ;
+- ratio Canvas `3 / 5` ;
+- mapping clavier/pointer ;
+- dépendances npm ;
+- lifecycle complet, assets, logging et provenance prévus pour `0-pre.5`.
+
+## Validation demandée
+
+Depuis la racine :
+
+```bash
+cargo fmt --all
+cargo fmt --all -- --check
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android Web deltas history
+python3 scripts/audit_distribution_layout.py
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+cargo test -p game-snake-poc-wasm
+cargo build -p game-snake-poc-wasm --target wasm32-unknown-unknown
+wasm-bindgen ../builds/sasedev-games/target/wasm32-unknown-unknown/debug/game_snake_poc_wasm.wasm --target web --out-dir ../builds/sasedev-games/game-snake-poc-web/wasm --out-name game_snake_poc_wasm
+(cd Web/game-snake-poc && npm install && npm run build && npm run dev)
+```
+
+Smoke navigateur sur `http://127.0.0.1:1434/main.html` : réduire la hauteur de fenêtre ou utiliser un viewport assez bas pour forcer le dépassement vertical, puis vérifier que seule la zone centrale défile avec SimpleBar tandis que header et footer restent fixes. Vérifier aussi que Canvas, clavier et boutons pointer restent fonctionnels.
+
+## Suite
+
+Après validation du scroll SimpleBar, `0-pre.5` peut ouvrir l'intégration plateforme complète prévue par le plan actif.

deltas/0.3.0/0-pre.4.md

@@ -0,0 +1,60 @@
+<!-- file: deltas/0.3.0/0-pre.4.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0-0-pre.4
+
+## Objectif
+
+Introduire le premier host navigateur direct Snake sans élargir encore le scope vers le lifecycle complet, les assets runtime, le logging ou la provenance de `0-pre.5`.
+
+## Livré
+
+- création de `Web/game-snake-poc/`, package Vite/TypeScript autonome hors workspace Cargo ;
+- reprise du template frontend des applications Desk KSP pour la structure `frontend/main.html`, `frontend/sass/`, `frontend/ts/` et le thème Bootstrap/Bootswatch Pulse ;
+- reprise uniquement des dépendances npm KSP utiles au navigateur direct : Bootstrap 5, Font Awesome, `sass-embedded`, TypeScript, Vite et types associés ;
+- exclusion volontaire des dépendances Tauri, SimpleBar et tracing spécifiques aux apps Desk ;
+- consommation des bindings `game-snake-poc-wasm` générés sous `../builds/sasedev-games/game-snake-poc-web/wasm/` ;
+- Canvas responsive prenant en compte `devicePixelRatio` ;
+- rendu de l'`EngineScene` normalisée sans dupliquer le gameplay ;
+- entrées clavier flèches, `WASD`, `ZQSD` et quatre boutons pointer/tactiles ;
+- état de chargement, score, longueur et retour d'erreur dans le shell ;
+- cache Vite et distribution frontend maintenus hors dépôt ;
+- audit de distribution étendu au host Web direct ;
+- enregistrement sous `history/0.3.0/0-pre.3.md` des validations utilisateur de `0-pre.3`.
+
+## Hors périmètre
+
+- lifecycle complet navigateur ;
+- assets runtime du POC ;
+- logging structuré Web ;
+- `RuntimeProvenance` ;
+- Tauri Snake ;
+- Android ;
+- extraction d'une abstraction Web commune non encore justifiée.
+
+## Validation demandée
+
+Depuis la racine :
+
+```bash
+cargo fmt --all
+cargo fmt --all -- --check
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android Web deltas history
+python3 scripts/audit_distribution_layout.py
+cargo check --workspace
+cargo clippy -p game-snake-poc-wasm --all-targets --all-features -- -D warnings
+cargo test -p game-snake-poc-wasm
+cargo build -p game-snake-poc-wasm --target wasm32-unknown-unknown
+wasm-bindgen ../builds/sasedev-games/target/wasm32-unknown-unknown/debug/game_snake_poc_wasm.wasm --target web --out-dir ../builds/sasedev-games/game-snake-poc-web/wasm --out-name game_snake_poc_wasm
+cd Web/game-snake-poc
+npm install
+npm run build
+npm run dev
+```
+
+Smoke navigateur : ouvrir `http://127.0.0.1:1434/main.html`, puis vérifier le chargement WASM, le Canvas, les quatre familles d'entrées prévues et le comportement responsive Desktop/mobile.
+
+## Suite
+
+`0-pre.5` ferme l'intégration plateforme du POC : lifecycle/resize complet, assets, logging, provenance runtime et non-régression Desktop SDL3.

deltas/0.3.0/0-pre.5.fix.1.md

@@ -0,0 +1,77 @@
+<!-- file: deltas/0.3.0/0-pre.5.fix.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0-0-pre.5.fix.1
+
+## Objectif
+
+Corriger uniquement l'exposition des assets runtime du host Snake Web en développement, après validation partielle de `0-pre.5`.
+
+## Défaut confirmé
+
+`cargo`, WASM, `wasm-bindgen` et le build Vite passent. Sous `vite dev`, le frontend échoue néanmoins avant le démarrage du jeu lors de `fetchJson()` : les routes `common/data/runtime.json` et `game/data/game.json` ne sont pas servies comme attendu.
+
+Les targets `vite-plugin-static-copy` utilisent des chemins source absolus. Le plugin conserve la structure source par défaut ; le `dest` seul ne constitue donc pas le contrat de route recherché.
+
+## Correction
+
+Les deux targets Vite utilisent désormais :
+
+```text
+rename: { stripBase: true }
+```
+
+Le contrat devient explicitement :
+
+```text
+assets/common/data/runtime.json         -> /common/data/runtime.json
+assets/game-snake-poc/data/game.json    -> /game/data/game.json
+```
+
+Ces routes doivent être identiques sous `vite dev` et dans `dist/`. Aucun asset source n'est dupliqué sous `Web/`.
+
+## Garde-fou
+
+`audit_distribution_layout.py` exige désormais `stripBase: true` sur les deux targets, en plus des namespaces `common/data` et `game/data`.
+
+## Historique
+
+`history/0.3.0/0-pre.5.md` consigne la validation partielle fournie par l'utilisateur et le défaut runtime exact.
+
+## Non modifié
+
+- gameplay Snake ;
+- adapter WASM/provenance ;
+- lifecycle/resize ;
+- logging frontend ;
+- SimpleBar/Canvas ;
+- runner Desktop SDL3 ;
+- ROADMAP et CHANGELOG.
+
+## Validation demandée
+
+Depuis la racine :
+
+```bash
+cargo fmt --all
+cargo fmt --all -- --check
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android Web deltas history
+python3 scripts/audit_distribution_layout.py
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+cargo test -p engine-v1-platform-api --all-targets --all-features
+cargo test -p game-snake-poc-wasm --all-targets --all-features
+cargo build -p game-snake-poc-wasm --target wasm32-unknown-unknown
+wasm-bindgen ../builds/sasedev-games/target/wasm32-unknown-unknown/debug/game_snake_poc_wasm.wasm --target web --out-dir ../builds/sasedev-games/game-snake-poc-web/wasm --out-name game_snake_poc_wasm
+cargo tree -p game-snake-poc-wasm --edges normal
+(cd Web/game-snake-poc && npm install && npm run build && npm run dev)
+```
+
+Smoke sur `http://127.0.0.1:1434/main.html` :
+
+1. `Assets` doit passer de `chargement…` à `snake / engine-v1` ;
+2. Snake doit démarrer ;
+3. la provenance doit quitter `unknown / unknown` dès qu'une classe/device et une entrée sont observées ;
+4. revalider lifecycle/resize/SimpleBar/Canvas/contrôles ;
+5. terminer par `cargo run -p game-snake-poc-desktop` pour la non-régression SDL3.

deltas/0.3.0/0-pre.5.md

@@ -0,0 +1,118 @@
+<!-- file: deltas/0.3.0/0-pre.5.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0-0-pre.5
+
+## Objectif
+
+Fermer l'intégration plateforme du premier POC Snake Web direct après validation de `0-pre.4.fix.3` : lifecycle/resize navigateur, assets runtime, logging frontend structuré, provenance `Web/Wasm/Browser` et non-régression du runner Desktop SDL3.
+
+## État précédent validé
+
+`0-pre.4.fix.3` a été accepté par l'utilisateur le 2026-09-20 : build Vite propre et smoke visuel/fonctionnel conforme, y compris Canvas portrait, contrôles et scroll SimpleBar du shell KSP-derived. Le résultat est consigné sous `history/0.3.0/0-pre.4.fix.3.md`.
+
+## Lifecycle et resize
+
+Le host Web ne laisse plus une boucle `requestAnimationFrame` implicite posséder tout le lifecycle :
+
+- `SnakeWebSession` expose `pause`, `resume`, `renderNow`, `refreshDeviceClass` et `dispose` ;
+- `visibilitychange` et `pagehide` suspendent les ticks ;
+- la reprise réinitialise l'origine temporelle et l'accumulateur afin d'éviter un rattrapage massif après un onglet caché ;
+- `pageshow` reprend et redessine ;
+- `ResizeObserver` redessine le Canvas et rafraîchit la classe d'appareil sans faire avancer la simulation ;
+- la destruction de page libère l'instance WASM.
+
+Le fixed-step gameplay reste dans Rust/WASM et aucun événement lifecycle n'est ajouté à `game-snake-poc`.
+
+## Assets Web
+
+Le package Vite déclare `vite-plugin-static-copy` et package explicitement les deux assets-sondes depuis les sources canoniques :
+
+```text
+assets/common/data/runtime.json      -> common/data/runtime.json
+assets/game-snake-poc/data/game.json -> game/data/game.json
+```
+
+`frontend/ts/assets.ts` charge et valide les deux JSON avant le démarrage WASM. Le shell affiche ensuite un statut d'assets afin que le smoke confirme le chargement réel. Aucune copie source durable n'est créée sous `Web/`.
+
+## Logging navigateur
+
+`frontend/ts/logging.ts` centralise les diagnostics Web sous forme d'événements `level / target / action / fields` vers la console du navigateur.
+
+Ce logging est spécifique au frontend navigateur direct :
+
+- il ne dépend pas de Tauri ;
+- il ne remplace pas `tracing` dans le code Rust ;
+- les runners natifs continuent d'utiliser `game-logging-lib`.
+
+## Provenance runtime
+
+`game-snake-poc-wasm` dépend désormais de `engine-v1-platform-api` et conserve une `RuntimeProvenance` réelle.
+
+Dimensions fixes :
+
+```text
+PlatformFamily = Web
+ExecutionModel = Wasm
+RuntimeHost = Browser
+```
+
+Le host renseigne ensuite la classe `Desktop/Phone/Tablet/Unknown` et le profil d'entrée `Unknown/KeyboardMouse/Touch/Mixed` selon les capacités et inputs observés. Ces dimensions sont exposées par le bridge WASM et affichées dans le shell.
+
+La crate de gameplay `game-snake-poc` reste sans dépendance plateforme.
+
+## Règles et documentation
+
+- `GAME-ASSET-007` fixe le packaging Web `common/` + `game/` sans copie source ;
+- `GAME-TRACE-005` distingue logging frontend navigateur et tracing Rust ;
+- `GAME-PLATFORM-024` fixe pause/reprise sans catch-up massif ;
+- `GAME-PLATFORM-025` fixe la provenance navigateur via `engine-v1-platform-api` ;
+- l'architecture assets/provenance, la documentation tracing/frontend et les gates sont réconciliées ;
+- `audit_distribution_layout.py` vérifie désormais les fichiers et branchements statiques de cette intégration.
+
+## Non modifié
+
+- règles de gameplay Snake ;
+- runner Snake Desktop SDL3 ;
+- moteur SDL3 ;
+- Android/Tauri ;
+- ROADMAP et CHANGELOG, réservés à la consolidation prévue par le plan.
+
+## Validation demandée
+
+Depuis la racine :
+
+```bash
+cargo fmt --all
+cargo fmt --all -- --check
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android Web deltas history
+python3 scripts/audit_distribution_layout.py
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+cargo test -p engine-v1-platform-api --all-targets --all-features
+cargo test -p game-snake-poc-wasm --all-targets --all-features
+cargo build -p game-snake-poc-wasm --target wasm32-unknown-unknown
+wasm-bindgen ../builds/sasedev-games/target/wasm32-unknown-unknown/debug/game_snake_poc_wasm.wasm --target web --out-dir ../builds/sasedev-games/game-snake-poc-web/wasm --out-name game_snake_poc_wasm
+cargo tree -p game-snake-poc-wasm --edges normal
+(cd Web/game-snake-poc && npm install && npm run build && npm run dev)
+```
+
+Smoke navigateur sur `http://127.0.0.1:1434/main.html` :
+
+1. vérifier que `Assets` passe à `snake / engine-v1` avant le statut `Prêt` ;
+2. vérifier que la provenance affiche `web / browser / wasm / ... / ...` ;
+3. utiliser clavier/souris puis tactile si disponible et vérifier l'évolution du profil d'entrée (`keyboard-mouse`, `touch` ou `mixed`) ;
+4. masquer l'onglet quelques secondes puis revenir : Snake ne doit pas accélérer pour rattraper le temps caché ;
+5. redimensionner la fenêtre : Canvas et provenance device doivent rester cohérents sans saut de gameplay ;
+6. revalider SimpleBar, clavier et contrôles pointer/tactiles.
+
+Puis vérifier la non-régression Desktop :
+
+```bash
+cargo run -p game-snake-poc-desktop
+```
+
+## Suite
+
+Si cette gate ne révèle ni duplication structurante ni défaut de frontière, la tranche conditionnelle `0-pre.6` est omise et la version peut entrer directement en `2-beta.1`. Sinon, `0-pre.6` ne traite que la correction/extraction prouvée par cette validation.

deltas/0.3.0/2-beta.1.md

@@ -0,0 +1,64 @@
+<!-- file: deltas/0.3.0/2-beta.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0-2-beta.1
+
+## Objectif
+
+Entrer en beta avec un scope `0.3.0` feature-complete et exécuter une validation large du POC Snake Web direct et de son témoin Desktop SDL3, sans introduire de nouveau comportement.
+
+## Baseline acceptée
+
+`0.3.0-0-pre.5.fix.1` est validée : audits, check/Clippy, tests plateforme/WASM, build WASM, build Vite, assets/provenance/inputs dans le navigateur et smoke Desktop SDL3 passent. Aucun défaut structurel ne justifie `0-pre.6`, qui est donc omise.
+
+## Changements
+
+- passage de la version workspace à `0.3.0-2-beta.1` ;
+- passage du package frontend Snake Web au jalon `0.3.0-2-beta.1` ;
+- ajout de l'historique validé `0-pre.5.fix.1` ;
+- réconciliation du plan `0.3.0` avec l'omission de `0-pre.6` ;
+- documentation de la gate beta release Web/Desktop.
+
+Aucun gameplay, bridge WASM, runtime SDL3, shell HTML/TypeScript ou contrat d'asset n'est modifié par cette tranche.
+
+## Validation attendue
+
+Depuis la racine :
+
+```bash
+cargo fmt --all
+cargo fmt --all -- --check
+
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android Web deltas history
+python3 scripts/audit_distribution_layout.py
+
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+cargo test --workspace --all-targets --all-features
+```
+
+Build et smoke Desktop Snake release :
+
+```bash
+cargo build -p game-snake-poc-desktop --release
+../builds/sasedev-games/target/release/game-snake-poc-desktop
+```
+
+Build WASM release et frontend production :
+
+```bash
+cargo build -p game-snake-poc-wasm --release --target wasm32-unknown-unknown
+wasm-bindgen ../builds/sasedev-games/target/wasm32-unknown-unknown/release/game_snake_poc_wasm.wasm \
+  --target web \
+  --out-dir ../builds/sasedev-games/game-snake-poc-web/wasm \
+  --out-name game_snake_poc_wasm
+
+(cd Web/game-snake-poc && npm install && npm run build && npm run preview)
+```
+
+Ouvrir `http://127.0.0.1:4174/main.html` puis vérifier : jeu visible, clavier/pointer, ratio Canvas, SimpleBar, assets `snake / engine-v1`, provenance cohérente, resize et pause/reprise sans rattrapage massif après masquage d'onglet.
+
+## Après validation
+
+Si cette gate beta est propre, la tranche suivante est `0.3.0-2-beta.2` pour la consolidation documentaire et la transmission : plan, documentation durable, `CHANGELOG.md`, `ROADMAP.md`, history et prompt de la version/session suivante.

deltas/0.3.0/2-beta.2.fix.1.md

@@ -0,0 +1,67 @@
+<!-- file: deltas/0.3.0/2-beta.2.fix.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0-2-beta.2.fix.1
+
+## Base requise
+
+`0.3.0-2-beta.2` validée mécaniquement par l'utilisateur le 2026-09-20.
+
+## Objectif
+
+Corriger la transmission documentaire de `2-beta.2` : rendre le prompt `0.3.1` suffisamment autonome pour limiter les rappels conversationnels et les fixes évitables, sans reproduire l'intégralité des règles KSP ni modifier le code/runtime.
+
+## Changements
+
+- enrichissement de `prompts/003-V0_3_1_START_PROMPT.md` avec ordre de lecture, handoff `0.3.0`, cadrage `pre.1`, invariants Tauri/Android/WASM, documentation, commandes, validations, forecast et condition de fin de session ;
+- ajout de `docs/rules/PROMPT_STRUCTURE.md`, inspiré du principe KSP de prompt autonome mais volontairement plus compact ;
+- ajout de règles explicites sur le rôle de `deltas/`/`history/`, le timing `ROADMAP`/`CHANGELOG`/prompt suivant et la séparation des validations utilisateur ;
+- ajout d'une politique `DOC-CRATE-*` pour décider utilement de `README.md`/`USAGE.md` sans créer de fichiers cérémoniels ;
+- clarification du cycle du prompt suivant : rédaction pendant la consolidation, vérification/complément à la première RC gelée ;
+- clarification du versionnement des fixes strictement documentaires : le delta porte `.fix.1` mais `workspace.package.version` et les packages runtime restent `0.3.0-2-beta.2` ;
+- ajout de `history/0.3.0/2-beta.2.md` avec les résultats réellement validés et le motif humain du fix ;
+- réconciliation du plan `0.3.0` avec ce correctif de transmission.
+
+`CHANGELOG.md` et `ROADMAP.md` ne sont pas modifiés : le fix ne change ni la publication candidate ni le scope produit.
+
+## Fichiers ajoutés
+
+```text
+docs/rules/PROMPT_STRUCTURE.md
+history/0.3.0/2-beta.2.md
+deltas/0.3.0/2-beta.2.fix.1.md
+```
+
+## Fichiers modifiés
+
+```text
+RULES.md
+docs/000-README.md
+docs/plans/001-V0_3_0_WEB_SNAKE_POC_PLAN.md
+docs/rules/RULES_DOCUMENTATION.md
+docs/rules/RULES_SESSION_PLANNING.md
+docs/rules/VERSION_WORKFLOW.md
+prompts/003-V0_3_1_START_PROMPT.md
+```
+
+## Fichiers supprimés
+
+Aucun.
+
+## Version technique
+
+Ce correctif est strictement documentaire. Conformément à `VER-DOCFIX-001`, il ne modifie ni `workspace.package.version` ni la version du package Web : la version technique reste `0.3.0-2-beta.2`.
+
+## Validation attendue
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android Web deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucun build Cargo/npm ni smoke n'est requis pour ce fix : aucun fichier consommé par le build/runtime n'est modifié.
+
+## Après validation
+
+Si la revue humaine du prompt enrichi est satisfaisante, ouvrir `0.3.0-3-rc.1` et appliquer la matrice RC. La RC vérifie/complète le prompt `0.3.1`, écrit l'entrée RC du `CHANGELOG.md` et ne rouvre pas le scope fonctionnel.

deltas/0.3.0/2-beta.2.fix.2.md

@@ -0,0 +1,66 @@
+<!-- file: deltas/0.3.0/2-beta.2.fix.2.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0-2-beta.2.fix.2
+
+## Base requise
+
+`0.3.0-2-beta.2.fix.1`.
+
+## Objectif
+
+Finaliser la gouvernance des commandes et des validations transmise au prompt `0.3.1`, afin d'éviter les gates surdimensionnées, les logs pollués et les workflows Tauri incorrects.
+
+Ce correctif est strictement documentaire. Il ne modifie aucun code, manifeste runtime, dépendance, configuration de build ni version technique.
+
+## Décisions consolidées
+
+- un fix strictement documentaire ne modifie aucune version Cargo/npm/Gradle/Tauri/Android ou autre version consommée par le runtime/build ;
+- tout changement de code Rust, manifeste Cargo, feature ou dépendance Rust déclenche `cargo fmt --all`, `cargo fmt --all -- --check`, `cargo check --workspace` puis `cargo clippy --workspace --all-targets --all-features -- -D warnings` ;
+- les audits Python sont sélectionnés selon les fichiers réellement touchés ;
+- `cargo test -p <crate> --all-targets --all-features` est la stratégie normale ;
+- `cargo test --workspace --all-targets --all-features` est réservé à un ou quelques jalons explicitement planifiés ou à une portée transverse incertaine ;
+- `cargo tree` n'est exécuté que si les dépendances/features changent ou qu'un diagnostic de frontière le justifie ;
+- toute commande nécessitant un changement de répertoire utilise `(cd <dir> && <commande>)` ;
+- dans une app Tauri, npm sert à gérer les dépendances frontend ; les smokes passent par `cargo tauri dev` et le packaging final/prefinal par `cargo tauri build`, les hooks Tauri possédant Vite/TypeScript/WASM.
+
+## Fichiers ajoutés
+
+```text
+history/0.3.0/2-beta.2.fix.1.md
+deltas/0.3.0/2-beta.2.fix.2.md
+```
+
+## Fichiers modifiés
+
+```text
+docs/plans/001-V0_3_0_WEB_SNAKE_POC_PLAN.md
+docs/rules/PROMPT_STRUCTURE.md
+docs/rules/RULES_COMMANDS.md
+docs/rules/RULES_SESSION_PLANNING.md
+docs/rules/RULES_VALIDATION_MATRIX.md
+docs/rules/VERSION_WORKFLOW.md
+prompts/003-V0_3_1_START_PROMPT.md
+```
+
+## Fichiers supprimés
+
+Aucun.
+
+## Version technique
+
+Aucune version technique n'est modifiée. La workspace et le package Web restent `0.3.0-2-beta.2`.
+
+## Validation attendue
+
+Les seuls fichiers touchés sont Markdown. L'audit applicable est donc :
+
+```bash
+python3 scripts/audit_markdown_tables.py docs prompts deltas history
+```
+
+Aucun `cargo fmt`, `cargo check`, Clippy, test Cargo, `cargo tree`, audit de distribution, npm, Tauri ou smoke n'est requis pour ce correctif documentaire.
+
+## Après validation
+
+Si la revue humaine confirme ces règles, ouvrir `0.3.0-3-rc.1`. La RC appliquera la matrice finale, écrira l'entrée RC du `CHANGELOG.md` et vérifiera une dernière fois le prompt `0.3.1` sans rouvrir le scope fonctionnel.

deltas/0.3.0/2-beta.2.md

@@ -0,0 +1,45 @@
+<!-- file: deltas/0.3.0/2-beta.2.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0-2-beta.2
+
+## Objectif
+
+Consolider la version feature-complete après validation de `2-beta.1`, préparer le gel RC et transmettre un contexte autonome à `0.3.1`, sans modifier le comportement runtime.
+
+## Baseline acceptée
+
+`0.3.0-2-beta.1` est validée : audits, format/check/Clippy, 34 tests workspace, Desktop Snake release et Web/WASM release passent.
+
+## Changements
+
+- passage de la version workspace et du package Web à `0.3.0-2-beta.2` ;
+- ajout de `history/0.3.0/2-beta.1.md` ;
+- classement des lignes `0.3.0` réellement livrées dans `ROADMAP.md` ;
+- ajout d'une baseline architecturale consolidée du POC Snake Web direct ;
+- ajout d'une matrice RC spécifique à `0.3.0` ;
+- réconciliation de l'étude `pre.1` avec le contrat autoritaire des archives de tag ;
+- mise à jour du plan actif avec le résultat beta ;
+- ajout du prompt `003-V0_3_1_START_PROMPT.md` pour le second host Snake Tauri Android.
+
+`CHANGELOG.md` est revu mais ne reçoit pas d'entrée beta : `DOC-CHG-002` et `DOC-CHG-003` réservent la synthèse publiée aux RC et stables. La matière de la future entrée RC est consolidée dans les documents durables de cette tranche.
+
+## Validation attendue
+
+```bash
+cargo fmt --all
+cargo fmt --all -- --check
+
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android Web deltas history
+python3 scripts/audit_distribution_layout.py
+
+cargo check --workspace
+(cd Web/game-snake-poc && npm install && npm run build)
+```
+
+Aucun test/smoke complet n'est requis par ce delta documentaire + métadonnées : `2-beta.1` vient de valider les artefacts release, et aucun code/runtime n'est modifié.
+
+## Après validation
+
+Si cette consolidation est acceptée, produire `0.3.0-3-rc.1` : gel fonctionnel, entrée RC du `CHANGELOG.md`, historique `2-beta.2`, réexécution de la matrice RC et vérification finale du prompt `0.3.1`.

deltas/0.3.0/3-rc.1.md

@@ -0,0 +1,88 @@
+<!-- file: deltas/0.3.0/3-rc.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0-3-rc.1
+
+## Base requise
+
+`0.3.0-2-beta.2.fix.2`.
+
+Cette base a été validée par revue humaine et audit Markdown proportionnel au correctif documentaire.
+
+## Objectif
+
+Créer la candidate de publication `0.3.0` sans rouvrir le scope fonctionnel.
+
+## Gel RC
+
+Le scope `0.3.0` est gelé. Cette tranche n'ajoute :
+
+- aucune fonctionnalité ;
+- aucune capability ;
+- aucun refactor architectural ;
+- aucune dépendance ;
+- aucun changement de gameplay ou de runtime.
+
+Seuls les correctifs autorisés par `VER-RC-*` pourront suivre sous `3-rc.1.fix.N`.
+
+## Changements
+
+- passage de `workspace.package.version` à `0.3.0-3-rc.1` ;
+- passage du package Web Snake à `0.3.0-3-rc.1` ;
+- affichage de la candidate courante dans `README.md` ;
+- création de l'entrée RC `0.3.0-3-rc.1` dans `CHANGELOG.md` ;
+- enregistrement de la validation `2-beta.2.fix.2` sous `history/0.3.0/` ;
+- réconciliation du plan `0.3.0` avec l'ouverture de la RC ;
+- revue finale de `prompts/003-V0_3_1_START_PROMPT.md` : aucune modification supplémentaire requise.
+
+Les métadonnées Android historiques restent inchangées : `0.3.0` ne livre pas un nouveau host Android. Le package Tauri Reflex historique reste également hors scope.
+
+## Validation RC
+
+Appliquer `docs/testing/004-V0_3_0_RC_VALIDATION_MATRIX.md`.
+
+### Gate workspace
+
+```bash
+cargo fmt --all
+cargo fmt --all -- --check
+
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android Web deltas history
+python3 scripts/audit_distribution_layout.py
+
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+cargo test --workspace --all-targets --all-features
+```
+
+Le test workspace complet est volontairement exécuté à ce jalon RC final. Aucun `cargo tree` n'est requis puisque les dépendances/features ne changent pas.
+
+### Desktop Snake release
+
+```bash
+cargo build -p game-snake-poc-desktop --release
+../builds/sasedev-games/target/release/game-snake-poc-desktop
+```
+
+Critères : démarrage, rendu, contrôles et arrêt propre.
+
+### Web/WASM release
+
+```bash
+cargo build -p game-snake-poc-wasm --release --target wasm32-unknown-unknown
+
+wasm-bindgen \
+  ../builds/sasedev-games/target/wasm32-unknown-unknown/release/game_snake_poc_wasm.wasm \
+  --target web \
+  --out-dir ../builds/sasedev-games/game-snake-poc-web/wasm \
+  --out-name game_snake_poc_wasm
+
+(cd Web/game-snake-poc && npm install && npm run build && npm run preview)
+```
+
+Ouvrir `http://127.0.0.1:4174/main.html` et confirmer Canvas, inputs, SimpleBar, assets, provenance, resize, lifecycle et absence d'erreur runtime bloquante.
+
+## Après validation
+
+Si la gate RC est propre et qu'aucun correctif n'est nécessaire, la promotion vers `0.3.0` est mécanique : versions stables, entrée stable du `CHANGELOG.md`, historique RC et delta de release, sans nouveau scope.

deltas/0.3.0/rel.001.md

@@ -0,0 +1,54 @@
+<!-- file: deltas/0.3.0/rel.001.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.0 — release stable
+
+## Base
+
+Base validée : `0.3.0-3-rc.1`.
+
+## Objet
+
+Promouvoir mécaniquement la candidate validée vers `0.3.0` sans introduire de nouveau comportement.
+
+## Changements
+
+La release stable :
+
+- passe `workspace.package.version` de `0.3.0-3-rc.1` à `0.3.0` ;
+- passe le package frontend Web Snake de `0.3.0-3-rc.1` à `0.3.0` ;
+- positionne `README.md` sur la stable `0.3.0` et indique `0.3.1` comme prochaine version planifiée mais non démarrée ;
+- ajoute l'entrée stable `0.3.0` dans `CHANGELOG.md` ;
+- enregistre la validation effective de la RC dans `history/0.3.0/3-rc.1.md` ;
+- clôt le plan `0.3.0` et réconcilie la baseline architecturale avec l'état effectivement publié.
+
+Les métadonnées Android et le package frontend Reflex/Tauri ne sont pas modifiés : ils n'appartiennent pas au chemin de distribution ajouté par `0.3.0`.
+
+Le prompt `prompts/003-V0_3_1_START_PROMPT.md` est conservé tel que validé en RC.
+
+## Frontière de release
+
+Aucun changement de gameplay, de Rust source, de dépendance, de build frontend, d'architecture ou de capability n'est introduit après la RC.
+
+## Validation
+
+La gate RC complète a déjà été validée sur un état fonctionnellement identique. La promotion stable ne requiert donc que les gates proportionnelles au changement de version et à la documentation :
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md CHANGELOG.md docs deltas history
+
+cargo check --workspace
+
+(cd Web/game-snake-poc && npm install && npm run build)
+```
+
+`cargo fmt`, Clippy, la suite workspace complète, `cargo tree`, l'audit de distribution et les smokes ne sont pas répétés : cette promotion ne touche ni code Rust, ni dépendance, ni layout de distribution, et ces gates ont déjà été validées sur `0.3.0-3-rc.1` fonctionnellement identique.
+
+## Publication
+
+Après validation de ce delta :
+
+- commit de release ;
+- tag stable `v0.3.0` ;
+- prochaine session ouverte uniquement à partir de la stable taggée `v0.3.0` et de `prompts/003-V0_3_1_START_PROMPT.md`.

deltas/0.3.1/0-pre.1.md

@@ -0,0 +1,146 @@
+<!-- file: deltas/0.3.1/0-pre.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.1-0-pre.1
+
+## Base
+
+Base autoritaire : archive téléchargée depuis le tag `v0.3.0` et fournie pour la reprise.
+
+L'archive a été testée et inspectée avant modification. Sa version workspace est `0.3.0`. Elle ne contient pas `.git`, conformément au contrat des archives taggées ; aucun état Git inaccessible n'est inventé.
+
+## Objet
+
+Ouvrir `0.3.1` par son gate obligatoire de cadrage : audit de baseline, revue complète des règles, inventaire de réutilisation Web/WASM, référence Tauri existante, exigences Tauri Android, sizing et planification.
+
+Aucun scaffold `game-snake-poc-tauri`, aucun frontend Tauri Snake et aucun changement de gameplay n'est introduit dans cette tranche.
+
+## Version
+
+La version workspace passe de :
+
+```text
+0.3.0
+```
+
+à :
+
+```text
+0.3.1-0-pre.1
+```
+
+Les versions npm des produits existants ne changent pas : cette tranche n'est pas une release de leurs frontends et `VER-TAURI-003`/`VER-TAURI-004` interdisent une synchronisation npm cérémonielle à chaque prerelease Cargo.
+
+## Audit de baseline
+
+Avant modification :
+
+```text
+unzip -t : no errors
+General Rust rule audit: clean
+Rust export completeness audit: 0 candidate(s)
+games.sasedev workspace audit: clean
+Markdown table audit: clean (5 table(s), 197 file(s))
+Distribution layout audit: clean (31 required path(s), 1 forbidden path(s) absent)
+```
+
+L'archive ne contient aucun lockfile interdit, `node_modules/`, `dist/`, `target/` ou binding WASM généré.
+
+Le détail est conservé dans `docs/studies/024-V0_3_1_TAURI_ANDROID_SNAKE_AUDIT.md`.
+
+## Corrections documentaires et normatives
+
+Cette tranche :
+
+- ferme l'index du plan `0.3.0` et ouvre le plan actif `0.3.1` ;
+- ajoute l'étude de cadrage et le plan vivant `0.3.1` ;
+- distingue explicitement les commandes Tauri Desktop des commandes Tauri Android ;
+- ajoute `cargo tauri android init`, `cargo tauri android dev` et `cargo tauri android build` à la matrice normative ;
+- corrige le prompt de reprise pour utiliser les commandes Android de Tauri au lieu des commandes Desktop ;
+- clarifie la différence entre la famille conceptuelle Mobile et le contrat V1 concret `PlatformFamily::Android` ;
+- distingue une sortie applicative Tauri soumise à `EngineGame::quit_requested` du Back système Android, qui reste une navigation système ;
+- documente la provenance attendue `Android / Wasm / TauriWebView`.
+
+## Réutilisation retenue
+
+Le second host doit :
+
+- conserver `game-snake-poc` comme gameplay unique ;
+- réutiliser `game-snake-poc-wasm` plutôt que créer un second adapter ;
+- généraliser seulement la provenance de host actuellement figée sur Web/Browser ;
+- réutiliser sélectivement Canvas/input/assets/shell du host Web ;
+- adapter lifecycle et tracing au WebView Tauri Android ;
+- suivre l'organisation Tauri `lib.rs` façade + `tauri.rs` assemblage + modules propriétaires ;
+- ne pas reprendre l'orchestrateur Python historique du POC Reflex.
+
+## Référence KSP
+
+L'archive KSP demandée est visible dans la bibliothèque, mais son export binaire vers l'environnement de génération a été refusé par le service de bibliothèque. Aucun audit intégral fictif de cette archive n'est donc déclaré.
+
+Les extraits indexés accessibles confirment néanmoins une organisation Desk avec `tauri.rs` pour l'assemblage/lifecycle et des modules propriétaires séparés tels que `app_state.rs`, `route_runtime.rs` et `frontend_logging.rs`. Les règles locales games.sasedev restent normatives.
+
+## Forecast
+
+```text
+0-pre.1  audit / règles / requirements / environnement / plan
+0-pre.2  scaffold Tauri Android + pipeline natif + bridge Snake WASM minimal
+0-pre.3  Canvas / input / assets / shell
+0-pre.4  lifecycle / provenance / tracing / Back + smoke mobile
+0-pre.5  conditionnel : extraction commune réellement justifiée
+2-beta.1 validation large + packaging Android
+2-beta.2 consolidation documentaire conditionnelle
+3-rc.1   candidate gelée
+0.3.1    release mécanique
+```
+
+## Validations exécutées dans l'environnement de génération
+
+Après constitution de l'état livré, exécuter :
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android Web deltas history
+python3 scripts/audit_distribution_layout.py
+```
+
+Aucun Cargo build/test/smoke final n'est attribué au générateur.
+
+## Validation utilisateur demandée
+
+Le manifest workspace change de version et les règles de commandes/validation sont modifiées. La gate utilisateur est :
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android Web deltas history
+python3 scripts/audit_distribution_layout.py
+
+cargo fmt --all
+cargo fmt --all -- --check
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+```
+
+Aucun test workspace complet n'est imposé par `pre.1` : aucun code, comportement ni graphe de dépendances n'est modifié. Il reste réservé à un jalon planifié ou à une portée transverse non bornable.
+
+Fournir également l'inventaire d'environnement qui conditionne `0-pre.2` :
+
+```bash
+rustc --version
+cargo --version
+cargo tauri --version
+rustup target list --installed
+node --version
+npm --version
+wasm-bindgen --version
+java -version
+printf 'JAVA_HOME=%s\nANDROID_HOME=%s\nNDK_HOME=%s\n' "$JAVA_HOME" "$ANDROID_HOME" "$NDK_HOME"
+adb version
+adb devices -l
+emulator -list-avds
+```
+
+Cette seconde série est un inventaire de prérequis, pas une gate déclarée réussie à l'avance.
+
+## Suite après validation
+
+Si la gate est propre et le cadrage accepté, passer à `0.3.1-0-pre.2` pour créer le host Tauri Android minimal. Toute absence d'outil indispensable ou incohérence de règle découverte par la gate produit d'abord un `0-pre.1.fix.N` borné.

deltas/0.3.1/0-pre.2.fix.1.md

@@ -0,0 +1,181 @@
+<!-- file: deltas/0.3.1/0-pre.2.fix.1.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.1-0-pre.2.fix.1
+
+## Base requise
+
+`0.3.1-0-pre.2`.
+
+Le delta `0-pre.2.md` reste immuable. La gate utilisateur du 2026-09-20 est consignée dans `history/0.3.1/0-pre.2.md`.
+
+## Objectif
+
+Corriger uniquement les défauts qui empêchent la gate de `0-pre.2` :
+
+- warning `missing_docs` du build script, bloquant sous Clippy `-D warnings` ;
+- résultat ignoré par le wrapper `tauri::mobile_entry_point` Android ;
+- incompatibilité du wrapper Gradle `8.14.3` généré par Tauri CLI `2.11.3` avec Java 25.
+
+Le scope fonctionnel de `0-pre.2` ne change pas. Canvas, contrôles, assets et lifecycle restent réservés aux tranches suivantes.
+
+## Version technique
+
+Le correctif touche du code Rust et le chemin de build Tauri/Android. La version workspace passe donc à :
+
+```text
+0.3.1-0-pre.2.fix.1
+```
+
+La version frontend locale de `package.json` reste `0.1.0` conformément à `VER-TAURI-003` et `VER-TAURI-004`.
+
+## Correction Rust
+
+`build.rs` possède désormais une rustdoc de crate et reste conforme aux règles Rust du workspace.
+
+Le point d'entrée est séparé en deux niveaux :
+
+- `run_runtime() -> Result<(), String>` possède l'exécution réelle ;
+- le host non mobile conserve `run() -> Result<(), String>` ;
+- le host mobile expose `#[tauri::mobile_entry_point] pub fn run()` et traite explicitement l'erreur éventuelle au lieu de laisser le macro ignorer un `Result` `must_use`.
+
+Le comportement fonctionnel Tauri n'est pas modifié.
+
+## Correction Gradle 9
+
+Le log utilisateur confirme que Tauri sélectionne lui-même le NDK installé sous `$ANDROID_HOME/ndk/30.0.14904198` puis injecte `NDK_HOME` dans son sous-processus. `NDK_HOME` n'est donc pas ajouté comme prérequis utilisateur.
+
+Le défaut réel est :
+
+```text
+Tauri CLI 2.11.3 -> gen/android/gradlew -> Gradle 8.14.3 -> Java 25
+Unsupported class file major version 69
+```
+
+Le Gradle global de la machine n'est pas consommé par ce chemin ; modifier uniquement le `PATH` ne corrige donc pas le wrapper Tauri.
+
+Le fix ajoute `crates/apps/game-snake-poc-tauri/scripts/prepare-android-gradle.mjs`. Avant chaque hook `dev`/`build`, ce script adapte idempotemment le projet généré `gen/android` vers la combinaison déjà adoptée par la migration Android upstream de Tauri :
+
+```text
+Gradle 9.6.1
+Android Gradle Plugin 9.3.1
+Kotlin Gradle Plugin 2.2.10
+```
+
+Il adapte aussi les ruptures Gradle 9 pertinentes du scaffold Tauri `2.11.x` :
+
+- `Project.exec` devient `ExecOperations` dans `BuildTask.kt` ;
+- les tâches Rust ciblées utilisent `tasks.register` et reçoivent explicitement `projectDir` ;
+- le DSL Android/Kotlin de l'application est aligné sur le template Gradle 9 upstream ;
+- les propriétés de compatibilité AGP 9 sont ajoutées ;
+- les anciennes propriétés Android devenues des defaults sont retirées.
+
+Le script est local à la crate Tauri et ne modifie ni le Gradle global ni le cache Cargo.
+
+## Bridge généré par tauri-build
+
+`tauri-build 2.6.3` régénère `gen/android/app/tauri.build.gradle.kts` pendant la compilation Rust, donc un patch effectué uniquement avant Cargo serait écrasé.
+
+`build.rs` applique par conséquent, immédiatement après `tauri_build::build()`, la migration :
+
+```text
+val implementation by configurations
+```
+
+vers :
+
+```text
+val implementation = configurations.getByName("implementation")
+```
+
+lorsque le fichier Android généré existe. Le build script reste un no-op pour ce point lors des checks hôte sans `gen/android`.
+
+## Hooks Tauri
+
+`package.json` conserve Tauri comme propriétaire du pipeline :
+
+```text
+cargo tauri android dev
+  -> beforeDevCommand
+  -> npm run dev
+  -> android:prepare
+  -> WASM
+  -> Vite
+```
+
+et de même pour `beforeBuildCommand`.
+
+`npm run dev` et `npm run build` ne deviennent pas des gates manuelles.
+
+## Documentation et garde-fous
+
+- `USAGE.md` retire `NDK_HOME` des prérequis utilisateur et explique la migration Gradle 9 ;
+- le plan vivant enregistre le défaut et le fix sans ouvrir `0-pre.3` ;
+- `audit_distribution_layout.py` exige désormais le hook Gradle, ses versions épinglées, la migration `ExecOperations` et le bridge `tauri-build` compatible Gradle 9 ;
+- le test synthétique du script Node a été exécuté deux fois sur le même fixture pour vérifier son idempotence.
+
+## Fichiers ajoutés
+
+```text
+crates/apps/game-snake-poc-tauri/scripts/prepare-android-gradle.mjs
+history/0.3.1/0-pre.2.md
+deltas/0.3.1/0-pre.2.fix.1.md
+```
+
+## Fichiers modifiés
+
+```text
+Cargo.toml
+README.md
+crates/apps/game-snake-poc-tauri/README.md
+crates/apps/game-snake-poc-tauri/USAGE.md
+crates/apps/game-snake-poc-tauri/build.rs
+crates/apps/game-snake-poc-tauri/package.json
+crates/apps/game-snake-poc-tauri/src/tauri.rs
+docs/plans/002-V0_3_1_TAURI_ANDROID_SNAKE_PLAN.md
+scripts/audit_distribution_layout.py
+```
+
+## Suppressions
+
+Aucune.
+
+## Validation générateur
+
+Les contrôles statiques applicables sont exécutés sur l'état livré. Les commandes Cargo/npm/Tauri/Gradle restent à exécuter côté utilisateur conformément à `CMD-GEN-007` et `CMD-BUILD-005`.
+
+## Gate utilisateur
+
+Depuis la racine :
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android Web deltas history
+python3 scripts/audit_distribution_layout.py
+
+cargo fmt --all
+cargo fmt --all -- --check
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+cargo test -p game-snake-poc-wasm --all-targets --all-features
+```
+
+Le build Web direct était déjà propre dans la gate `0-pre.2` et aucune de ses sources n'est modifiée par ce fix ; il n'est pas nécessaire de répéter sa gate pour ce correctif borné.
+
+Le projet Android généré existe déjà chez l'utilisateur. Ne pas rejouer `cargo tauri android init`. Relancer directement :
+
+```bash
+(cd crates/apps/game-snake-poc-tauri && cargo tauri android dev)
+```
+
+Le hook doit afficher avant le build Android :
+
+```text
+Prepared Tauri Android Gradle 9.6.1 / AGP 9.3.1 / Kotlin 2.2.10.
+```
+
+Puis le wrapper doit utiliser Gradle 9.6.1 au lieu de 8.14.3. Le smoke reste celui de `0-pre.2` : démarrage sur l'appareil/AVD, bridge Rust, chargement WASM, provenance `android / tauri-webview / wasm / unknown / unknown` et tracing sans erreur bloquante.
+
+## Suite
+
+Si cette gate est propre, `0-pre.2` est considéré réparé et la progression reprend sur `0.3.1-0-pre.3` conformément au plan vivant.

deltas/0.3.1/0-pre.2.fix.2.delete.txt

@@ -0,0 +1,2 @@
+crates/apps/game-snake-poc-tauri/scripts/prepare-android-gradle.mjs
+history/0.3.1/0-pre.2.md

deltas/0.3.1/0-pre.2.fix.2.md

@@ -0,0 +1,122 @@
+<!-- file: deltas/0.3.1/0-pre.2.fix.2.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.1-0-pre.2.fix.2
+
+## Base
+
+Base déclarée : `0.3.1-0-pre.2.fix.1`.
+
+## Objet
+
+Ce fix retire la migration Gradle 9 locale introduite par `fix.1`, revient au chemin Android officiellement généré par Tauri 2 stable et corrige l'audit workspace pour qu'il n'analyse pas le contenu généré sous `gen/` comme du code source du dépôt.
+
+Il corrige également une violation documentaire de `fix.1` : `history/0.3.1/0-pre.2.md` avait été créé alors que `0-pre.2` n'était pas accepté. Aucune entrée `history/` n'est conservée pour ce jalon tant que sa gate n'est pas verte.
+
+## Cause confirmée
+
+Le smoke `0-pre.2` a établi trois faits distincts :
+
+- Tauri sélectionne correctement le NDK side-by-side sous `$ANDROID_HOME/ndk/<version>` ; l'absence de `NDK_HOME` utilisateur n'est pas la cause du défaut ;
+- le wrapper Android généré par Tauri CLI `2.11.3` utilise Gradle `8.14.3`, qui ne peut pas s'exécuter avec Java 25 ;
+- `cargo tauri android init` crée légitimement `gen/android/app/src/main/assets`, mais l'audit `GAME-ASSET-001` parcourait jusque-là les répertoires générés.
+
+La dernière CLI Tauri 2 stable vérifiée pendant ce fix est `2.11.5`. Son template Android conserve Gradle `8.14.3` et AGP `8.11.0`. La migration Gradle 9 existe upstream mais n'est pas encore publiée dans la branche stable Tauri 2 ; la reproduire par patch local ferait du projet games.sasedev le mainteneur d'un fork implicite du template Tauri.
+
+## Correction Tauri Android
+
+Le host Snake ne modifie plus `gen/android` :
+
+- suppression de `scripts/prepare-android-gradle.mjs` ;
+- suppression du hook `android:prepare` dans `package.json` ;
+- restauration des hooks Tauri vers le seul pipeline WASM/Vite ;
+- `build.rs` délègue uniquement à `tauri_build::build()` ;
+- l'audit de distribution interdit désormais la réintroduction d'un patch `gen/android` dans ces deux surfaces.
+
+Pour Tauri 2 stable, le contrat local devient celui recommandé par Tauri : `JAVA_HOME` doit pointer vers un JDK compatible avec le wrapper généré, de préférence le JBR livré avec Android Studio. Le Java 25 global peut rester installé ; il ne doit simplement pas être le JDK utilisé par les commandes Android Tauri tant que le wrapper stable ne le supporte pas.
+
+Le Gradle global installé sous `/opt/gradle` n'est pas utilisé par `gen/android/gradlew` et n'entre pas dans le contrat de build.
+
+## Correction de l'audit workspace
+
+`gen/` est déjà un chemin généré et ignoré par `.gitignore`. `audit_project_workspace_rules.py` exclut désormais ces arbres pour les contrôles qui portent sur la propriété du code source :
+
+- `GAME-ASSET-001` n'interdit plus les `assets` créés par le projet Android Tauri généré ;
+- `GAME-ANDROID-001` n'interdit plus les éventuelles sources Java générées sous `gen/`.
+
+Les assets et sources Java réellement versionnés hors des emplacements autorisés restent interdits.
+
+## Historique
+
+`history/0.3.1/0-pre.2.md` est supprimé. `DOC-HIST-002` et `DOC-HIST-003` imposent qu'une entrée d'historique ne soit créée qu'après acceptation effective du jalon. Le prochain delta ne recréera cette entrée que si la gate `0-pre.2.fix.2` est validée.
+
+## Suppressions
+
+Le manifest `deltas/0.3.1/0-pre.2.fix.2.delete.txt` supprime :
+
+- `crates/apps/game-snake-poc-tauri/scripts/prepare-android-gradle.mjs` ;
+- `history/0.3.1/0-pre.2.md`.
+
+Après extraction du delta à la racine du dépôt, appliquer les suppressions avec :
+
+```bash
+while IFS= read -r path; do
+    rm -f -- "$path"
+done < deltas/0.3.1/0-pre.2.fix.2.delete.txt
+```
+
+## Fichiers modifiés
+
+- `Cargo.toml` ;
+- `README.md` ;
+- `crates/apps/game-snake-poc-tauri/build.rs` ;
+- `crates/apps/game-snake-poc-tauri/package.json` ;
+- `crates/apps/game-snake-poc-tauri/README.md` ;
+- `crates/apps/game-snake-poc-tauri/USAGE.md` ;
+- `docs/plans/002-V0_3_1_TAURI_ANDROID_SNAKE_PLAN.md` ;
+- `scripts/audit_project_workspace_rules.py` ;
+- `scripts/audit_distribution_layout.py`.
+
+## Fichiers ajoutés
+
+- `deltas/0.3.1/0-pre.2.fix.2.md` ;
+- `deltas/0.3.1/0-pre.2.fix.2.delete.txt`.
+
+## Validation statique du générateur
+
+Le générateur peut exécuter les audits statiques et vérifier explicitement que les chemins générés Tauri ne déclenchent plus `GAME-ASSET-001` / `GAME-ANDROID-001`. Ces contrôles ne remplacent pas les gates build/runtime utilisateur.
+
+## Gate utilisateur
+
+Après application du delta et de son manifest de suppression :
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android Web deltas history
+python3 scripts/audit_distribution_layout.py
+
+cargo fmt --all
+cargo fmt --all -- --check
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+cargo test -p game-snake-poc-wasm --all-targets --all-features
+```
+
+Avant le smoke Android, sélectionner le JBR d'Android Studio dans le shell. Exemple si Android Studio est sous `/opt/android-studio` :
+
+```bash
+export JAVA_HOME=/opt/android-studio/jbr
+"$JAVA_HOME/bin/java" -version
+(cd crates/apps/game-snake-poc-tauri && cargo tauri android dev)
+```
+
+Si Android Studio se trouve ailleurs, remplacer `/opt/android-studio/jbr` par son chemin réel. Ne pas exécuter `npm run dev` directement et ne pas rejouer `cargo tauri android init` pour ce fix lorsque `gen/android` existe déjà.
+
+## Critère d'acceptation
+
+Le fix est accepté lorsque :
+
+- les trois audits Python sont propres malgré la présence du `gen/android` local ;
+- Cargo/Clippy/tests ciblés sont propres ;
+- `cargo tauri android dev` n'échoue plus sur `Unsupported class file major version 69` ;
+- le host minimal atteint le smoke Android prévu par `0-pre.2`.

deltas/0.3.1/0-pre.2.md

@@ -0,0 +1,161 @@
+<!-- file: deltas/0.3.1/0-pre.2.md -->
+<!-- version: 1 -->
+
+# Delta 0.3.1-0-pre.2
+
+## Base requise
+
+`0.3.1-0-pre.1`, validée par l'utilisateur le 2026-09-20.
+
+## Objectif
+
+Créer le host Tauri Android minimal de Snake sans dupliquer le gameplay, sans créer un second adapter WASM et sans réintroduire de build orchestré par Python.
+
+Cette tranche vise le premier démarrage Android et la validation des frontières Tauri/WASM/tracing. Le Canvas, les contrôles, les assets et le lifecycle complet restent réservés à `0-pre.3` et `0-pre.4` conformément au plan vivant.
+
+## Audit Tauri KSP direct
+
+L'archive fournie `khadhroony-solana-project-v0.3.15.zip` a été extraite et les six crates `ksp-app-*-desk` ont été vérifiées directement. Elles possèdent toutes les frontières structurantes retenues pour games.sasedev :
+
+```text
+src/lib.rs
+src/tauri.rs
+package.json
+vite.config.ts
+tauri.conf.json
+capabilities/default.json
+tauri-plugin-tracing côté Rust
+@fltsci/tauri-plugin-tracing côté frontend
+```
+
+Le nouveau host Snake reprend cette organisation, avec un scope volontairement plus petit. Le Tauri Reflex historique reste seulement une référence de compatibilité : son orchestration Python n'est pas reproduite.
+
+## Changements Rust et WASM
+
+- passage du workspace à `0.3.1-0-pre.2` ;
+- ajout de `game-snake-poc-tauri` au workspace ;
+- création de la façade `src/lib.rs`, de l'assemblage `src/tauri.rs` et du module propriétaire `src/runtime.rs` ;
+- ajout du point d'entrée mobile `#[cfg_attr(mobile, tauri::mobile_entry_point)]` ;
+- initialisation du subscriber partagé via `game-logging-lib` avant le premier événement Rust ;
+- installation de `tauri-plugin-tracing` ;
+- généralisation minimale de `game-snake-poc-wasm::configure_runtime_provenance` afin que le même adapter accepte explicitement la famille et le host observés ;
+- conservation de `ExecutionModel::Wasm` dans l'adapter ;
+- adaptation du Web direct pour fournir explicitement `web / browser` ;
+- ajout d'un test ciblé `android / tauri-webview / wasm` ;
+- généralisation de la rustdoc `RuntimeHost::TauriWebView`, qui n'est plus décrite comme Desktop uniquement.
+
+## Frontend et build Tauri
+
+La nouvelle app contient :
+
+- `package.json`, `tsconfig.json` et `vite.config.ts` ;
+- un frontend minimal sous `frontend/` ;
+- un bridge IPC vers le descriptor runtime Rust ;
+- le chargement des bindings produits depuis `game-snake-poc-wasm` ;
+- le tracing frontend via `@fltsci/tauri-plugin-tracing` ;
+- `tauri.conf.json` et `capabilities/default.json` ;
+- un icon POC cohérent avec le host Tauri historique ;
+- `README.md` et `USAGE.md` initiaux.
+
+Les hooks Tauri exécutent eux-mêmes le build Cargo WASM, `wasm-bindgen` puis Vite. Les outputs restent sous `../builds/sasedev-games/`. Aucun script Python n'est impliqué dans ce chemin.
+
+`cargo tauri android init` reste une opération locale de la gate : son répertoire `gen/` est généré et ignoré, donc il n'est pas distribué dans le delta.
+
+## NDK et JDK
+
+La machine de validation possède plusieurs NDK sous `$ANDROID_HOME/ndk/`; `NDK_HOME` n'est donc pas imposé globalement par le dépôt. Si la CLI Tauri exige une valeur explicite pendant `android init/dev`, utiliser ponctuellement le chemin exact de la version NDK concernée.
+
+`JAVA_HOME` reste également facultatif tant que `java` est résolu correctement par la CLI dans l'environnement courant. Les deux variables deviennent des outils de diagnostic local, pas des invariants source du projet.
+
+## Audit de distribution
+
+`audit_distribution_layout.py` couvre désormais le host Tauri Snake minimal : fichiers requis, hooks Tauri, outputs WASM externes au dépôt, point d'entrée mobile, bridge tracing, provenance Android/TauriWebView et interdiction de Python/`console.*` dans le chemin touché.
+
+## Fichiers ajoutés
+
+```text
+crates/apps/game-snake-poc-tauri/Cargo.toml
+crates/apps/game-snake-poc-tauri/README.md
+crates/apps/game-snake-poc-tauri/USAGE.md
+crates/apps/game-snake-poc-tauri/build.rs
+crates/apps/game-snake-poc-tauri/capabilities/default.json
+crates/apps/game-snake-poc-tauri/frontend/css/main.css
+crates/apps/game-snake-poc-tauri/frontend/main.html
+crates/apps/game-snake-poc-tauri/frontend/ts/bridge.ts
+crates/apps/game-snake-poc-tauri/frontend/ts/logging.ts
+crates/apps/game-snake-poc-tauri/frontend/ts/main.ts
+crates/apps/game-snake-poc-tauri/icons/icon.png
+crates/apps/game-snake-poc-tauri/package.json
+crates/apps/game-snake-poc-tauri/src/lib.rs
+crates/apps/game-snake-poc-tauri/src/main.rs
+crates/apps/game-snake-poc-tauri/src/runtime.rs
+crates/apps/game-snake-poc-tauri/src/tauri.rs
+crates/apps/game-snake-poc-tauri/tauri.conf.json
+crates/apps/game-snake-poc-tauri/tsconfig.json
+crates/apps/game-snake-poc-tauri/vite.config.ts
+history/0.3.1/0-pre.1.md
+```
+
+## Fichiers modifiés
+
+```text
+Cargo.toml
+README.md
+Web/game-snake-poc/frontend/ts/provenance.ts
+crates/apps/game-snake-poc-wasm/src/runtime.rs
+crates/apps/game-snake-poc-wasm/unit_tests/runtime.rs
+crates/engines/engine-v1-platform-api/src/environment.rs
+docs/plans/002-V0_3_1_TAURI_ANDROID_SNAKE_PLAN.md
+scripts/audit_distribution_layout.py
+```
+
+## Validation générateur
+
+Les audits statiques applicables sont exécutés avant livraison. Aucun `cargo`, `npm`, `wasm-bindgen`, Gradle, Tauri Android ou smoke n'est déclaré validé par le générateur.
+
+## Gate utilisateur
+
+Appliquer d'abord la gate workspace :
+
+```bash
+python3 scripts/audit_rust_workspace_rules.py
+python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android Web deltas history
+python3 scripts/audit_distribution_layout.py
+
+cargo fmt --all
+cargo fmt --all -- --check
+cargo check --workspace
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+cargo test -p game-snake-poc-wasm --all-targets --all-features
+```
+
+Comme l'API de provenance partagée est utilisée par le Web direct, reconstruire ses bindings et son frontend :
+
+```bash
+cargo build -p game-snake-poc-wasm --target wasm32-unknown-unknown
+wasm-bindgen ../builds/sasedev-games/target/wasm32-unknown-unknown/debug/game_snake_poc_wasm.wasm --target web --out-dir ../builds/sasedev-games/game-snake-poc-web/wasm --out-name game_snake_poc_wasm
+(cd Web/game-snake-poc && npm install && npm run build)
+```
+
+Puis initialiser et lancer le nouveau host par Tauri, sans exécuter ses scripts npm de build directement :
+
+```bash
+(cd crates/apps/game-snake-poc-tauri && npm install)
+(cd crates/apps/game-snake-poc-tauri && cargo tauri android init)
+(cd crates/apps/game-snake-poc-tauri && cargo tauri android dev)
+```
+
+Critères du smoke `android dev` :
+
+- l'app démarre sur l'appareil/AVD choisi ;
+- le frontend affiche `android / tauri-webview / wasm / unknown / unknown` ;
+- le bridge Rust répond ;
+- le frontend charge `game-snake-poc-wasm` ;
+- les logs Rust et frontend atteignent le pipeline tracing/logcat ;
+- aucune erreur runtime bloquante n'est visible.
+
+`cargo tauri android build` reste reporté au jalon de packaging prévu par le plan.
+
+## Suite après validation
+
+Si la gate est propre, passer automatiquement à `0.3.1-0-pre.3` pour intégrer le Canvas Snake, les inputs et les assets dans le WebView Tauri. Tout défaut source de `0-pre.2` produit d'abord un `0-pre.2.fix.N` borné.

docs/000-README.md

@@ -1,5 +1,5 @@
 <!-- file: docs/000-README.md -->
-<!-- version: 18 -->
+<!-- version: 28 -->
 
 # Documentation games.sasedev
 
@@ -7,6 +7,17 @@
 
 - [`objectives/001-PROJECT_OBJECTIVES.md`](objectives/001-PROJECT_OBJECTIVES.md) — finalité, principes structurants, stratégie de construction et vision du SDK.
 
+## Idées et études
+
+- [`ideas/000-README.md`](ideas/000-README.md) — rôle des idées non engagées et règles de maturation.
+- [`studies/000-README.md`](studies/000-README.md) — rôle des études comparatives non normatives.
+
+## Plans
+
+- [`plans/000-README.md`](plans/000-README.md) — plans vivants des versions ; le plan actif porte notamment le découpage prévisionnel souple des prereleases.
+- [`plans/001-V0_3_0_WEB_SNAKE_POC_PLAN.md`](plans/001-V0_3_0_WEB_SNAKE_POC_PLAN.md) — plan clôturé de `0.3.0`, premier POC Snake Web direct.
+- [`plans/002-V0_3_1_TAURI_ANDROID_SNAKE_PLAN.md`](plans/002-V0_3_1_TAURI_ANDROID_SNAKE_PLAN.md) — plan actif de `0.3.1`, second host Snake Tauri Android.
+
 ## Architecture
 
 - [`architecture/001-WORKSPACE_ARCHITECTURE.md`](architecture/001-WORKSPACE_ARCHITECTURE.md) — workspace, générations de moteur, jeux, runners, assets et Android.
@@ -17,6 +28,12 @@
 - [`architecture/009-ENGINE_V1_RENDER_SCENE.md`](architecture/009-ENGINE_V1_RENDER_SCENE.md) — scène 2D portable, rectangles normalisés et backend SDL3.
 - [`architecture/010-RUNTIME_PROVENANCE.md`](architecture/010-RUNTIME_PROVENANCE.md) — provenance plateforme/device/runtime/input pour sessions, scores et analytics.
 - [`architecture/011-POST_0_1_0_DIRECTION.md`](architecture/011-POST_0_1_0_DIRECTION.md) — décisions de transition entre le POC stable 0.1.0 et la conception modulaire 0.2.0.
+- [`architecture/012-MODULAR_LAYERING_AND_OWNERSHIP.md`](architecture/012-MODULAR_LAYERING_AND_OWNERSHIP.md) — architecture durable kernel/capabilities/game-systems/games/adapters/providers/services/tooling.
+- [`architecture/013-NETWORK_AND_SERVER_ARCHITECTURE.md`](architecture/013-NETWORK_AND_SERVER_ARCHITECTURE.md) — Web/API, realtime, transports, asset delivery auto-hébergé et frontières serveur.
+- [`architecture/014-UROBURAS_TARGET_ARCHITECTURE.md`](architecture/014-UROBURAS_TARGET_ARCHITECTURE.md) — ownership cible des besoins Uroburas et ordre Mode 1 → Mode 3 → Mode 2.
+- [`architecture/015-PLATFORM_POC_ARCHITECTURE.md`](architecture/015-PLATFORM_POC_ARCHITECTURE.md) — rôle des POC `0.3.x`, Snake comme sonde et critères d'extraction.
+- [`architecture/016-V0_2_0_CONSOLIDATED_BASELINE.md`](architecture/016-V0_2_0_CONSOLIDATED_BASELINE.md) — synthèse de la baseline destinée au gel RC `0.2.0`.
+- [`architecture/017-V0_2_0_RC_REVIEW.md`](architecture/017-V0_2_0_RC_REVIEW.md) — checklist de cohérence et scope gelé de la candidate `0.2.0-3-rc.1`.
 
 ## Jeux
 
@@ -40,7 +57,7 @@
 
 ## Règles
 
-Voir [`../RULES.md`](../RULES.md), notamment [`rules/RULES_COMMANDS.md`](rules/RULES_COMMANDS.md) pour la politique d'exécution des commandes.
+Voir [`../RULES.md`](../RULES.md), notamment [`rules/RULES_DOCUMENTATION.md`](rules/RULES_DOCUMENTATION.md) pour la gouvernance documentaire, [`rules/RULES_COMMANDS.md`](rules/RULES_COMMANDS.md) pour la politique d'exécution, [`rules/RULES_VALIDATION_MATRIX.md`](rules/RULES_VALIDATION_MATRIX.md) pour la matrice des gates, [`rules/RULES_SESSION_PLANNING.md`](rules/RULES_SESSION_PLANNING.md) pour le cadrage des sessions, [`rules/PROMPT_STRUCTURE.md`](rules/PROMPT_STRUCTURE.md) pour le contrat des prompts de reprise et [`rules/RULES_SERVER_HOSTING.md`](rules/RULES_SERVER_HOSTING.md) pour la portabilité d'auto-hébergement.
 
 ## Validation
 
@@ -52,12 +69,16 @@ Voir [`../RULES.md`](../RULES.md), notamment [`rules/RULES_COMMANDS.md`](rules/R
 - [`testing/001-TEST_ARCHITECTURE.md`](testing/001-TEST_ARCHITECTURE.md) — séparation `unit_tests/` / `tests/`, tests ciblés et tracing de test.
 - [`testing/002-BETA_VALIDATION_MATRIX.md`](testing/002-BETA_VALIDATION_MATRIX.md) — matrice beta Desktop SDL3, Tauri/WASM et Android multi-appareils.
 - [`testing/003-RC_VALIDATION_MATRIX.md`](testing/003-RC_VALIDATION_MATRIX.md) — matrice RC de reproductibilité, packaging final et promotion vers `0.1.0`.
+- [`testing/004-V0_3_0_RC_VALIDATION_MATRIX.md`](testing/004-V0_3_0_RC_VALIDATION_MATRIX.md) — gate RC spécifique au POC Snake Web direct et à son témoin Desktop SDL3.
 - [`development/003-TRACING_AND_DIAGNOSTICS.md`](development/003-TRACING_AND_DIAGNOSTICS.md) — socle `tracing`, subscriber et appender communs.
 - [`development/004-SDL3_DESKTOP_PREREQUISITES.md`](development/004-SDL3_DESKTOP_PREREQUISITES.md) — prérequis SDL3 Desktop, stratégie de liaison système et vérification `pkg-config`.
 - [`development/005-DESKTOP_WINDOW_POLICY.md`](development/005-DESKTOP_WINDOW_POLICY.md) — taille initiale, redimensionnement et séparation future entre fenêtre physique et résolution virtuelle.
 - [`development/006-ANDROID_RUST_NATIVE_BUILD.md`](development/006-ANDROID_RUST_NATIVE_BUILD.md) — build `cdylib` Rust Android, cargo-ndk, packaging `jniLibs` et symbole `SDL_main`.
 - [`development/007-ANDROID_JNI_BRIDGE.md`](development/007-ANDROID_JNI_BRIDGE.md) — frontière Java/JNI minimale, version de contrat et séparation avec l'input SDL3.
+- [`development/008-WASM_TAURI_POC.md`](development/008-WASM_TAURI_POC.md) — baseline historique Reflex Tauri/WebAssembly et génération WASM associée.
+- [`development/009-SNAKE_WEB_WASM_BUILD.md`](development/009-SNAKE_WEB_WASM_BUILD.md) — build Cargo + `wasm-bindgen` natif de l'adapter Snake pour le navigateur direct.
+- [`development/010-SNAKE_WEB_FRONTEND.md`](development/010-SNAKE_WEB_FRONTEND.md) — host Web direct Snake sous Vite/TypeScript, shell Bootstrap 5, Canvas, lifecycle, assets, provenance et contrôles clavier/tactiles.
 
 ## Historique validé
 
-- [`../history/README.md`](../history/README.md) — convention et navigation de l'historique transitoire immuable des jalons validés.
+- [`../history/000-README.md`](../history/000-README.md) — convention et navigation de l'historique transitoire immuable des jalons validés.

docs/architecture/001-WORKSPACE_ARCHITECTURE.md

@@ -1,5 +1,5 @@
 <!-- file: docs/architecture/001-WORKSPACE_ARCHITECTURE.md -->
-<!-- version: 5 -->
+<!-- version: 7 -->
 
 # Architecture du workspace
 
@@ -22,7 +22,8 @@ games.sasedev/
 │       ├── game-reflex-poc-desktop/
 │       ├── game-snake-poc-desktop/
 │       ├── game-reflex-poc-tauri/
-│       └── game-reflex-poc-wasm/
+│       ├── game-reflex-poc-wasm/
+│       └── game-snake-poc-wasm/
 ├── assets/
 │   ├── common/
 │   ├── game-reflex-poc/
@@ -31,6 +32,8 @@ games.sasedev/
 │   ├── common/
 │   ├── game-reflex-poc/
 │   └── game-snake-poc/
+├── Web/
+│   └── game-snake-poc/
 ├── docs/
 ├── deltas/
 ├── prompts/
@@ -69,15 +72,12 @@ Le runtime devra conserver une distinction logique entre ressources communes et
 
 Chaque crate de jeu reste une bibliothèque. Une crate binaire Desktop séparée sous `crates/apps/` la consomme pour permettre les itérations locales rapides. Cette séparation évite d’introduire `main`, des choix de plateforme ou du code de lancement dans le gameplay réutilisable.
 
-## Variante Tauri / WebAssembly
+## Adapters WebAssembly et variante Tauri
 
-La variante Tauri est distincte du runner SDL3 natif.
+Les adapters WASM sont distincts des runners SDL3 natifs et ne déplacent aucune règle de gameplay hors des crates de jeu.
 
-`game-reflex-poc-tauri` porte deux faces du même launcher :
+`game-reflex-poc-wasm` adapte le POC Reflex à `wasm-bindgen` pour le host Tauri/WebView existant. `game-snake-poc-wasm` adapte séparément Snake pour le premier host navigateur direct de `0.3.0`. Dans les deux cas, l'adapter expose l'état et la scène portable ; il ne possède pas les règles du jeu.
 
-- une bibliothèque `wasm32-unknown-unknown` qui adapte `game-reflex-poc` à `wasm-bindgen` ;
+`game-reflex-poc-tauri` reste le binaire natif Tauri qui héberge la WebView Reflex locale. Son frontend Vite/TypeScript pilote un Canvas et appelle l'adapter Reflex WASM. La crate Tauri suit le modèle des apps Desk KSP : façade `lib.rs`, pont `tauri.rs`, modules propriétaires séparés et frontend local à la crate.
-- un binaire natif Tauri qui héberge la WebView locale.
 
-Le frontend statique sous `Tauri/game-reflex-poc/frontend/` pilote un Canvas et appelle l'adaptateur WASM. Les règles Reflex restent exclusivement dans `game-reflex-poc`.
+Le host Web Snake direct réside sous `Web/game-snake-poc/`. Ce package Vite/TypeScript consomme `game-snake-poc-wasm`, reprend la structure HTML/Sass/TypeScript et le thème Bootstrap/Bootswatch des applications Desk KSP sans dépendre de Tauri, traduit clavier/tactile vers les quatre directions logiques et dessine l'`EngineScene` dans un Canvas. Il reste extérieur au workspace Cargo et ne contient aucune règle de gameplay.
-
-La crate Tauri suit le modèle des apps Desk KSP : façade `lib.rs`, pont `tauri.rs`, modules propriétaires séparés et frontend Vite/TypeScript local à la crate.

docs/architecture/003-SDL3_PLATFORM_ABSTRACTION.md

@@ -15,17 +15,26 @@ Engine API
 SDL3 boundary
  ┌───┼───────────────┐
  │   │               │
-Desktop           Android            Web
+Desktop           Mobile             Web
-native            SDL/JNI            WASM/browser
+SDL native        SDL/native         WASM/browser
+ │                 │
+Linux/Windows/     Android/iOS
+macOS
 ```
 
 ## Desktop
 
+La famille Desktop réserve Linux, Windows et macOS. Leur support effectif dépend des backends, bibliothèques et contraintes de distribution disponibles au moment de l'implémentation.
+
 Le runner Desktop est la cible d'itération la plus rapide. Il utilise la crate lib du jeu et, à terme, le runtime SDL3 natif. Les entrées disponibles peuvent inclure clavier, souris, trackpad, gamepad et joystick.
 
 La cible Desktop sert à tester le gameplay, le rendu, la boucle de jeu, l'audio et les abstractions communes sans imposer un déploiement sur émulateur ou téléphone.
 
-## Android
+## Mobile
+
+La famille Mobile réserve Android et iOS. Téléphone et tablette sont des classes de device et ne doivent pas être confondus avec l'OS ou le backend de rendu.
+
+### Android
 
 Android empaquette le jeu natif dans une application standard. La structure cible combine : SDL3 Android, une bibliothèque native Rust, la couche Java commune, les extensions Java spécifiques au jeu, les assets communs et spécifiques, puis les SDK Android requis.
 
@@ -33,6 +42,10 @@ Les fonctionnalités suivantes restent côté plateforme Android : lifecycle, JN
 
 Le gameplay Rust ne doit pas dépendre des classes Java ni d'une régie publicitaire particulière.
 
+### iOS
+
+iOS est une cible réservée pour une évolution future. Aucun support de distribution iOS n'est exigé dans le POC actuel. L'architecture ne doit toutefois pas introduire une dépendance structurelle qui rendrait impossible un backend SDL/native ou un adapter iOS ultérieur.
+
 ## Web / WASM
 
 La cible Web est prévue comme cible ultérieure. SDL3 peut être utilisé avec une chaîne Web adaptée, notamment Emscripten, tandis que le navigateur fournit ses propres contraintes de boucle d'événements, audio, stockage, permissions et interaction utilisateur.

docs/architecture/004-INPUT_AND_CONTROLS.md

@@ -1,5 +1,5 @@
 <!-- file: docs/architecture/004-INPUT_AND_CONTROLS.md -->
-<!-- version: 7 -->
+<!-- version: 9 -->
 
 # Abstraction des entrées et contrôles
 
@@ -97,6 +97,22 @@ Pour souris et tactile :
 
 Reflex conserve son impulsion `Primary` sur `Down` et reste donc indépendant de la reconnaissance du swipe.
 
+## Baseline Snake portable `0.3.0`
+
+La crate `game-snake-poc` consomme uniquement le contrat générique `engine-v1-common` pour son gameplay. Elle ne dépend pas de `engine-v1-platform-api`, de SDL3, du DOM ou d'un type de périphérique concret.
+
+Le contrat d'entrée Snake retenu pour le premier POC Web est volontairement minimal :
+
+- `Left`, `Right`, `Up` et `Down` pilotent la direction ;
+- le rejet d'un demi-tour opposé reste une règle du gameplay Snake ;
+- `Primary`, `Secondary`, `Pause` et le pointeur normalisé ne sont pas requis par le gameplay Snake actuel ;
+- le host traduit clavier, swipe ou boutons virtuels vers les mêmes actions directionnelles ;
+- le rendu reste exposé par `EngineGame::scene` sous forme d'`EngineScene`, sans dépendance au Canvas ou à SDL3.
+
+L'adapter WASM de `0-pre.3` adapte ce contrat existant plutôt que créer un second modèle d'entrée ou de rendu propre au Web. Il mémorise au plus une direction logique en attente ; `tick()` la consomme pour le prochain update puis remet l'entrée en attente à zéro. Un événement clavier ou tactile ne fait donc pas avancer la simulation à lui seul.
+
+Le host Web reste responsable de transformer ses événements physiques ou widgets en appels `left`, `right`, `up` ou `down`, puis de piloter la cadence des `tick()`. Les besoins de provenance, monétisation ou autres services plateforme appartiennent au host/launcher et ne justifient pas une dépendance plateforme inutilisée dans la crate de gameplay.
+
 ## Requête de sortie
 
 La plateforme ne décide plus directement de terminer un jeu. Elle traduit l'événement physique en `QuitRequest` :

docs/architecture/005-ASSET_ARCHITECTURE.md

@@ -1,5 +1,5 @@
 <!-- file: docs/architecture/005-ASSET_ARCHITECTURE.md -->
-<!-- version: 3 -->
+<!-- version: 4 -->
 
 # Architecture des assets
 
@@ -92,3 +92,16 @@ assets/game/...
 ```
 
 Les répertoires `build/generated/` restent des artefacts jetables.
+
+## Web navigateur direct
+
+Le POC Snake Web valide le même espace logique sans copier les sources dans `Web/`. Vite package explicitement les assets nécessaires depuis `assets/` vers :
+
+```text
+dist/common/data/runtime.json
+dist/game/data/game.json
+```
+
+Le serveur Vite de développement expose les mêmes URL runtime. Le frontend charge donc `common://data/runtime.json` et `game://data/game.json` sous leurs chemins de distribution `./common/data/runtime.json` et `./game/data/game.json`, puis valide leur schéma avant de démarrer la session.
+
+Cette première intégration ne transforme pas encore `game-assets-lib` en loader navigateur : la librairie Rust reste responsable de la validation/résolution de chemins physiques pour les hosts qui disposent d'un filesystem, tandis que Vite possède le packaging Web. Une abstraction commune ne sera extraite que si plusieurs hosts en ont réellement besoin.