From ba718ce4ecc8938518eb475dc4c512206faa7966 Mon Sep 17 00:00:00 2001 From: SinuS Von SifriduS Date: Sun, 20 Sep 2026 18:16:32 +0200 Subject: [PATCH] 0.3.1-0-pre.1 --- Cargo.toml | 4 +- README.md | 4 +- deltas/0.3.1/0-pre.1.md | 146 ++++++++++++ docs/000-README.md | 5 +- docs/architecture/010-RUNTIME_PROVENANCE.md | 16 +- docs/plans/000-README.md | 5 +- .../002-V0_3_1_TAURI_ANDROID_SNAKE_PLAN.md | 176 ++++++++++++++ docs/rules/PROMPT_STRUCTURE.md | 4 +- docs/rules/RULES_COMMANDS.md | 13 +- docs/rules/RULES_PROJECT.md | 6 +- docs/rules/RULES_VALIDATION_MATRIX.md | 11 +- docs/studies/000-README.md | 6 +- .../024-V0_3_1_TAURI_ANDROID_SNAKE_AUDIT.md | 223 ++++++++++++++++++ prompts/003-V0_3_1_START_PROMPT.md | 16 +- 14 files changed, 601 insertions(+), 34 deletions(-) create mode 100644 deltas/0.3.1/0-pre.1.md create mode 100644 docs/plans/002-V0_3_1_TAURI_ANDROID_SNAKE_PLAN.md create mode 100644 docs/studies/024-V0_3_1_TAURI_ANDROID_SNAKE_AUDIT.md diff --git a/Cargo.toml b/Cargo.toml index 5bd0b2a..1566df6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,5 @@ # file: Cargo.toml -# version: 69 +# version: 70 [workspace] resolver = "3" @@ -20,7 +20,7 @@ members = [ ] [workspace.package] -version = "0.3.0" +version = "0.3.1-0-pre.1" edition = "2024" license = "MIT" repository = "https://git.sasedev.com/Sasedev/games" diff --git a/README.md b/README.md index fe01f76..83e1f85 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ - + # games.sasedev @@ -26,7 +26,7 @@ Workspace expérimental puis productif pour des jeux multiplateformes principale Version stable de référence : `0.3.0`. -Version suivante planifiée : `0.3.1` (non démarrée). +Version de développement courante : `0.3.1-0-pre.1`. 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. diff --git a/deltas/0.3.1/0-pre.1.md b/deltas/0.3.1/0-pre.1.md new file mode 100644 index 0000000..f359160 --- /dev/null +++ b/deltas/0.3.1/0-pre.1.md @@ -0,0 +1,146 @@ + + + +# 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é. diff --git a/docs/000-README.md b/docs/000-README.md index 4c07b98..1105805 100644 --- a/docs/000-README.md +++ b/docs/000-README.md @@ -1,5 +1,5 @@ - + # Documentation games.sasedev @@ -15,7 +15,8 @@ ## 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 actif de `0.3.0`, premier POC Snake Web direct. +- [`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 diff --git a/docs/architecture/010-RUNTIME_PROVENANCE.md b/docs/architecture/010-RUNTIME_PROVENANCE.md index d3313b9..a50c87e 100644 --- a/docs/architecture/010-RUNTIME_PROVENANCE.md +++ b/docs/architecture/010-RUNTIME_PROVENANCE.md @@ -1,5 +1,5 @@ - + # Provenance d'environnement d'exécution @@ -45,7 +45,7 @@ RuntimeHost = Native InputProfile = KeyboardMouse ``` -Le futur POC Tauri/WASM : +Un host Tauri Desktop/WASM : ```text PlatformFamily = Desktop @@ -55,7 +55,17 @@ RuntimeHost = TauriWebView InputProfile = KeyboardMouse ``` -Une version Web dans un navigateur de téléphone pourra au contraire être `PlatformFamily = Web`, `DeviceClass = Phone`, `ExecutionModel = Wasm`, `RuntimeHost = Browser`, `InputProfile = Touch`. +Le POC Tauri Android de `0.3.1` doit au contraire utiliser : + +```text +PlatformFamily = Android +DeviceClass = Phone ou Tablet +ExecutionModel = Wasm +RuntimeHost = TauriWebView +InputProfile = Touch ou Mixed selon les entrées réellement observées +``` + +Une version Web dans un navigateur de téléphone pourra être `PlatformFamily = Web`, `DeviceClass = Phone`, `ExecutionModel = Wasm`, `RuntimeHost = Browser`, `InputProfile = Touch`. ## Classements et équité diff --git a/docs/plans/000-README.md b/docs/plans/000-README.md index abfea0e..76f8588 100644 --- a/docs/plans/000-README.md +++ b/docs/plans/000-README.md @@ -1,5 +1,5 @@ - + # Plans de versions games.sasedev @@ -11,4 +11,5 @@ Le `ROADMAP.md` reste la trajectoire macroscopique du projet ; les deltas décri ## Plans -- [`001-V0_3_0_WEB_SNAKE_POC_PLAN.md`](001-V0_3_0_WEB_SNAKE_POC_PLAN.md) — plan actif de `0.3.0`, baseline Snake et premier POC Web direct. +- [`001-V0_3_0_WEB_SNAKE_POC_PLAN.md`](001-V0_3_0_WEB_SNAKE_POC_PLAN.md) — plan clôturé de `0.3.0`, baseline Snake et premier POC Web direct. +- [`002-V0_3_1_TAURI_ANDROID_SNAKE_PLAN.md`](002-V0_3_1_TAURI_ANDROID_SNAKE_PLAN.md) — plan actif de `0.3.1`, second host Snake Tauri Android. diff --git a/docs/plans/002-V0_3_1_TAURI_ANDROID_SNAKE_PLAN.md b/docs/plans/002-V0_3_1_TAURI_ANDROID_SNAKE_PLAN.md new file mode 100644 index 0000000..f6841af --- /dev/null +++ b/docs/plans/002-V0_3_1_TAURI_ANDROID_SNAKE_PLAN.md @@ -0,0 +1,176 @@ + + + +# Plan v0.3.1 — second host Snake Tauri Android + +## But de la version + +`0.3.1` doit ajouter un second host Snake réellement exécutable sous Tauri Android en réutilisant la baseline Web/WASM validée par `0.3.0`. + +La version ne doit ni déplacer le gameplay hors de `game-snake-poc`, ni créer un second adapter Snake, ni transformer immédiatement les similitudes Web/Tauri en framework générique. + +Base stable : `0.3.0`. + +Cadrage : [`../studies/024-V0_3_1_TAURI_ANDROID_SNAKE_AUDIT.md`](../studies/024-V0_3_1_TAURI_ANDROID_SNAKE_AUDIT.md). + +## Décisions acquises + +- la nouvelle crate sera `crates/apps/game-snake-poc-tauri` ; +- `0.3.1` valide uniquement sa cible Android ; +- `game-snake-poc` reste inchangé sauf défaut réellement découvert ; +- `game-snake-poc-wasm` reste l'unique adapter Snake WASM et recevra seulement la généralisation de provenance nécessaire au second host ; +- le frontend Tauri part du comportement réellement validé dans `Web/game-snake-poc`, avec adaptation de lifecycle et logging ; +- `lib.rs` est une façade/reexport et `tauri.rs` reste l'assemblage Tauri ; +- le tracing frontend utilise `@fltsci/tauri-plugin-tracing` ; +- les hooks Tauri possèdent le build frontend/WASM ; +- aucun nouveau chemin de build n'est piloté par Python ; +- `README.md` et `USAGE.md` seront créés avec l'app : architecture pour le premier, prérequis/commandes/smokes pour le second ; +- `cargo tauri android init/dev/build` sont les commandes mobiles de référence ; +- SimpleBar et `resize-observer-polyfill` ne sont pas ajoutés au host Tauri sans besoin démontré. + +## Scope + +La version couvre : + +- création de la crate/app Tauri Snake ; +- initialisation de la cible Android par Tauri ; +- pipeline Rust/WASM + Vite/TypeScript possédé par Tauri sans Python ; +- consommation de `game-snake-poc-wasm` ; +- shell Canvas, contrôles touch et comportement responsive nécessaires au jeu ; +- assets communs et spécifiques Snake ; +- lifecycle mobile/WebView ; +- provenance `Android / Wasm / TauriWebView` ; +- tracing Rust/Tauri/frontend ; +- politique de sortie/Back conforme au moteur ; +- build/package et smoke sur AVD/appareil disponible aux jalons prévus ; +- comparaison du code Web direct/Tauri après fonctionnement réel afin de décider s'il existe une extraction commune justifiée. + +Hors scope : Tauri Desktop Snake comme cible validée, iOS, Android SDL3 multi-ABI additionnel, réseau realtime, Uroburas, ads, billing, auth et leaderboard. + +## Prévision souple + +### `0-pre.1` — cadrage et règles + +Audit complet de l'archive stable, règles, baseline Web/WASM, Tauri Reflex, références Desk KSP accessibles, environnement Android historique et commandes Tauri mobiles actuelles. + +Livraison : étude `024`, présent plan, correction des règles Tauri Android, clarification `PlatformFamily`, index documentaires et ouverture de la version technique `0.3.1-0-pre.1`. + +Aucun scaffold Tauri Snake n'est créé. + +### `0-pre.2` — host Tauri Android minimal + +Créer `game-snake-poc-tauri` avec : + +- manifest Cargo/build script/config Tauri/capabilities ; +- `lib.rs` façade, `tauri.rs` assemblage et modules propriétaires minimaux ; +- point d'entrée `run()` mobile annoté `#[cfg_attr(mobile, tauri::mobile_entry_point)]` dans le module propriétaire puis réexporté par `lib.rs` ; +- frontend Vite/TypeScript minimal ; +- bridge tracing initialisé ; +- hooks de build natifs, sans Python ; +- cible Android initialisée via Tauri ; +- chargement du même adapter `game-snake-poc-wasm` après généralisation minimale de provenance ; +- `README.md` et `USAGE.md` initiaux. + +La tranche vise un premier démarrage Tauri Android minimal, pas encore toute la finition input/lifecycle. + +Gate utilisateur : audits, Cargo workspace strict, build WASM nécessaire, `cargo tauri android dev` sur un AVD ou appareil disponible. `cargo tauri android build` reste reporté aux phases finales sauf besoin diagnostique. + +### `0-pre.3` — shell Snake, Canvas, input et assets + +Réutiliser sélectivement le host Web validé : + +- rendu Canvas et session fixed-step ; +- shell responsive pertinent ; +- contrôles directionnels touch/pointer et clavier lorsque disponible ; +- resize/orientation ; +- assets canoniques communs + Snake ; +- absence de dépendances Web-only inutiles. + +Aucune extraction commune n'est réalisée uniquement pour éviter quelques fichiers similaires pendant la mise au point. + +### `0-pre.4` — lifecycle, provenance, tracing et sortie mobile + +Stabiliser : + +- background/foreground et reprise sans rattrapage massif ; +- rotation/resize ; +- provenance `Android / Wasm / TauriWebView` + device/input observés ; +- tracing Rust/Tauri/frontend ; +- sorties applicatives conformes à `EngineGame::quit_requested` sans détourner le Back système Android ; +- smokes AVD et, si disponible, appareil réel. + +Cette tranche doit rendre le second host fonctionnel de bout en bout. + +### `0-pre.5` — extraction conditionnelle + +Créer uniquement si l'état `0-pre.4` montre une duplication réellement durable entre `Web/game-snake-poc` et le frontend Tauri. + +Une extraction possible doit rester bornée à une responsabilité clairement partagée, par exemple projection/rendu Canvas, mapping input Web ou helpers d'assets. Lifecycle et logging restent host-specific s'ils divergent réellement. + +Si aucune extraction n'est justifiée, cette tranche est omise. + +### `2-beta.1` — validation large et packaging Android + +Prévoir : + +- audits statiques applicables ; +- `cargo fmt --all -- --check` ; +- `cargo check --workspace` ; +- Clippy workspace strict ; +- suite workspace complète à ce jalon planifié ; +- build WASM release et bindings ; +- `cargo tauri android build` ; +- APK/AAB selon le livrable de validation ; +- install/smoke AVD ; +- install/smoke appareil ARM64 réel si disponible ; +- vérification que les outputs restent hors racine du dépôt lorsqu'ils sont configurables par le projet. + +### `2-beta.2` — consolidation documentaire conditionnelle + +Réserver seulement si les validations beta demandent une consolidation substantielle de `README.md`, `USAGE.md`, architecture, matrice de validation ou plan. Ne pas créer cette tranche par cérémonial. + +### `3-rc.1` — candidate gelée + +Gel fonctionnel, reproductibilité, packaging Android RC et validation finale selon les règles RC applicables. Aucun nouveau framework ni nouveau host. + +### `0.3.1` — release stable + +Promotion mécanique de la RC validée : versions stables, changelog, history et clôture du plan. Aucun ajout fonctionnel. + +## Inventaire environnement requis avant `0-pre.2` + +La gate `0-pre.1` doit recevoir au minimum : + +```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 +``` + +L'absence d'un outil ne doit pas être masquée. Elle devient un prérequis concret de `0-pre.2` ou motive un fix borné de `0-pre.1`. + +## Critères de fermeture de 0.3.1 + +La version peut entrer en RC lorsque : + +- Snake est jouable dans le WebView Tauri Android sans gameplay dupliqué ; +- le même adapter WASM sert Web direct et Tauri Android avec provenance exacte ; +- lifecycle/input/assets/tracing/Back ont un comportement explicite et validé ; +- le chemin de build ne dépend d'aucun orchestrateur Python ; +- le packaging Tauri Android est reproductible ; +- les smokes prévus sur cible Android ont été exécutés ; +- aucune extraction commune non prouvée n'a été introduite ; +- la documentation opérateur et architecture reflète l'état réel. + +## Version suivante + +`0.3.2` reste réservée à Tauri Desktop + Snake et à une éventuelle factorisation WebView seulement après deux consommateurs réels. diff --git a/docs/rules/PROMPT_STRUCTURE.md b/docs/rules/PROMPT_STRUCTURE.md index efcb300..520b792 100644 --- a/docs/rules/PROMPT_STRUCTURE.md +++ b/docs/rules/PROMPT_STRUCTURE.md @@ -1,5 +1,5 @@ - + # Structure des prompts de reprise @@ -24,7 +24,7 @@ Le prompt rappelle les invariants qui évitent les erreurs de workflow et renvoi ## Commandes avec répertoire et Tauri - **PROMPT-STR-016** — Le prompt rappelle que toute commande nécessitant un `cd` est englobée dans un sous-shell, par exemple `(cd && )`, afin de ne pas modifier le répertoire courant pour les commandes suivantes. -- **PROMPT-STR-017** — Lorsqu'une version touche Tauri, le prompt rappelle que `npm` sert à gérer les dépendances frontend mais que les builds/smokes passent par Tauri : `(cd && cargo tauri dev)` pour le smoke courant et `(cd && cargo tauri build)` aux phases finales de packaging prévues. Les hooks Tauri possèdent Vite/TypeScript/WASM ; `npm run dev`/`npm run build` ne deviennent pas des gates manuelles Tauri. +- **PROMPT-STR-017** — Lorsqu'une version touche Tauri, le prompt rappelle que `npm` sert à gérer les dépendances frontend mais que les builds/smokes passent par Tauri. Il utilise les commandes de la cible concernée : `(cd && cargo tauri dev)` / `cargo tauri build` pour Desktop, ou `(cd && cargo tauri android dev)` / `cargo tauri android build` pour Android. Les hooks Tauri possèdent Vite/TypeScript/WASM ; `npm run dev`/`npm run build` ne deviennent pas des gates manuelles Tauri. ## Documentation et traçabilité à rappeler diff --git a/docs/rules/RULES_COMMANDS.md b/docs/rules/RULES_COMMANDS.md index a89c665..c413dd8 100644 --- a/docs/rules/RULES_COMMANDS.md +++ b/docs/rules/RULES_COMMANDS.md @@ -1,5 +1,5 @@ - + # Règles d'exécution des commandes @@ -61,11 +61,14 @@ - **CMD-WEB-003** — Le POC Tauri/WASM historique `0.1.0` utilise `scripts/build_reflex_tauri_wasm.py` ; ce script reste une référence de baseline mais ne doit pas être réutilisé comme orchestrateur par un POC `0.3.x`, conformément à `CMD-BUILD-004`. - **CMD-WEB-004** — Les fichiers produits par `wasm-bindgen` sont générés localement et ne sont pas commités. - **CMD-WEB-005** — Dans une app Tauri, `npm` sert uniquement à gérer les dépendances frontend lorsque nécessaire, par exemple `npm i `, `npm i -D ` ou leur opération inverse. Les scripts `npm run dev`, `npm run build` ou équivalents ne sont pas des gates manuelles : Vite/TypeScript/WASM sont déclenchés par les hooks Tauri configurés. -- **CMD-WEB-006** — Le smoke normal d'une app Tauri est lancé via `(cd && cargo tauri dev)`. Cette commande possède le serveur Vite et les hooks frontend nécessaires. -- **CMD-WEB-007** — Le packaging Tauri est validé dans les phases finales prévues par le plan via `(cd && cargo tauri build)`, typiquement en beta préfinale, RC ou avant release selon le scope. Il n'est pas exécuté après chaque petit delta Tauri. +- **CMD-WEB-006** — Le smoke normal d'une app Tauri Desktop est lancé via `(cd && cargo tauri dev)`. Cette commande possède le serveur Vite et les hooks frontend nécessaires. +- **CMD-WEB-007** — Le packaging Tauri Desktop est validé dans les phases finales prévues par le plan via `(cd && cargo tauri build)`, typiquement en beta préfinale, RC ou avant release selon le scope. Il n'est pas exécuté après chaque petit delta Tauri. - **CMD-WEB-008** — Pour un host Web navigateur direct sous `Web//`, les commandes npm/Vite peuvent être exécutées directement, toujours dans un sous-shell lorsqu'un changement de répertoire est nécessaire, par exemple `(cd Web/ && npm install && npm run build)`. - **CMD-WEB-009** — Le build d'un host Web direct qui consomme un adapter `wasm-bindgen` exécute d'abord le build Rust/WASM et la génération des bindings hors dépôt, puis seulement le build TypeScript/Vite. - **CMD-WEB-010** — Un smoke navigateur manuel d'un host Web direct vérifie au minimum le chargement WASM, le Canvas, les entrées prévues par la tranche et le comportement responsive concerné. +- **CMD-WEB-011** — Une cible Tauri Android existante est initialisée depuis sa crate avec `(cd && cargo tauri android init)` lorsqu'elle ne possède pas encore le projet mobile généré requis ; cette initialisation n'est pas rejouée comme gate ordinaire. +- **CMD-WEB-012** — Le smoke interactif d'une app Tauri Android utilise `(cd && cargo tauri android dev)` ; il remplace `cargo tauri dev` pour cette cible mobile. +- **CMD-WEB-013** — Le packaging Tauri Android utilise `(cd && cargo tauri android build)` dans les phases finales prévues par le plan ; `--apk` ou `--aab` est ajouté uniquement lorsque le livrable visé le requiert. ## Git et fichiers générés @@ -78,7 +81,7 @@ - **CMD-BETA-001** — À l'entrée en beta, `scripts/audit_distribution_layout.py` vérifie les frontières statiques nécessaires aux runners et packagings supportés. - **CMD-BETA-002** — La transition alpha vers beta exécute une suite Cargo workspace complète en plus des tests ciblés. -- **CMD-BETA-003** — Si la version touche le périmètre Tauri, le plan réserve au moins une validation de packaging dans une phase finale appropriée via `(cd && cargo tauri build)` ; les itérations et smokes courants utilisent `cargo tauri dev`. +- **CMD-BETA-003** — Si la version touche le périmètre Tauri, le plan réserve au moins une validation de packaging dans une phase finale appropriée avec la commande Tauri correspondant à la cible : `cargo tauri build` pour Desktop ou `cargo tauri android build` pour Android. Les smokes utilisent de même `cargo tauri dev` ou `cargo tauri android dev` selon la cible. - **CMD-BETA-004** — Les APK Debug servent à la validation multi-appareils beta ; la signature de publication appartient à la phase RC/stable. ## RC et release @@ -86,7 +89,7 @@ - **CMD-RC-001** — L'entrée en RC gèle le périmètre fonctionnel de la version courante ; seuls les correctifs, la reproductibilité des builds, le packaging, la documentation de livraison et les défauts de release sont admis. - **CMD-RC-002** — La validation d'une RC exécute `cargo test --workspace --all-targets --all-features` en plus des audits, du check et de Clippy strict. - **CMD-RC-003** — Les deux runners Desktop natifs sont construits en `--release` et font l'objet d'un smoke sur les binaires de release. -- **CMD-RC-004** — Une RC Tauri est construite via `(cd && cargo tauri build)` ; ses hooks possèdent toujours le build WASM et Vite/TypeScript. Les smokes interactifs restent lancés avec `(cd && cargo tauri dev)`. +- **CMD-RC-004** — Une RC Tauri est construite avec la commande de packaging correspondant à sa cible : `(cd && cargo tauri build)` pour Desktop ou `(cd && cargo tauri android build)` pour Android. Ses hooks possèdent toujours le build WASM et Vite/TypeScript ; les smokes utilisent la variante `dev` correspondante. - **CMD-RC-005** — Android RC revalide au minimum x86_64 sur AVD et ARM64 sur appareil réel avec les APK issus de l'état RC. - **CMD-RC-006** — Les secrets de signature, keystores et credentials de publication ne sont jamais commités. Leur présence est une condition externe de publication, pas une donnée du dépôt. - **CMD-RC-007** — Une RC n'est promue en stable que si aucun correctif `.fix.N` n'est nécessaire après la gate RC complète. diff --git a/docs/rules/RULES_PROJECT.md b/docs/rules/RULES_PROJECT.md index 7db72a3..4701e6d 100644 --- a/docs/rules/RULES_PROJECT.md +++ b/docs/rules/RULES_PROJECT.md @@ -1,5 +1,5 @@ - + # Règles spécifiques games.sasedev @@ -72,7 +72,7 @@ - **GAME-PLATFORM-011** — Les traces frontend Tauri passent par `@fltsci/tauri-plugin-tracing` vers `tauri-plugin-tracing`/`tracing`; les `console.*` applicatifs directs sont interdits hors fallback interne. - **GAME-PLATFORM-012** — Le plugin tracing Tauri ne remplace pas l'initialisation du subscriber Rust ; une app Tauri initialise le runtime de logging partagé avant son premier événement `tracing`. -- **GAME-PLATFORM-013** — Les demandes de sortie Tauri sont évaluées par la politique `EngineGame::quit_requested` avant toute fermeture native. +- **GAME-PLATFORM-013** — Les demandes de sortie applicatives Tauri sont évaluées par la politique `EngineGame::quit_requested` avant toute fermeture native contrôlée par l'application. Cette règle n'impose pas de consommer le Back système Android, qui reste régi par `GAME-PLATFORM-014`. - **GAME-BUILD-001** — Les artefacts générés Cargo, Tauri, Vite et caches frontend sont placés hors de la racine du dépôt, sous `../builds/sasedev-games/`; un répertoire racine `builds/` dans le dépôt est interdit. @@ -81,7 +81,7 @@ ## Réservation de plateformes -- **GAME-PLATFORM-016** — Les familles de plateformes réservées sont Desktop, Mobile et Web. Desktop inclut potentiellement Linux, Windows et macOS ; Mobile inclut potentiellement Android et iOS. +- **GAME-PLATFORM-016** — Les familles conceptuelles réservées sont Desktop, Mobile et Web. Desktop inclut potentiellement Linux, Windows et macOS ; Mobile inclut potentiellement Android et iOS. Le contrat runtime V1 reste volontairement plus concret : `PlatformFamily` expose actuellement `Android`, `Desktop` et `Web` ; un host Tauri Android utilise donc `PlatformFamily::Android` tant qu'aucune généralisation Mobile/iOS n'est justifiée. - **GAME-PLATFORM-017** — Téléphone, tablette et futures classes de device sont des dimensions distinctes de l'OS et du backend technique. - **GAME-PLATFORM-018** — SDL3 reste le backend natif de référence du POC, mais l'architecture de jeu ne doit pas assimiler une plateforme à SDL ni empêcher un adapter différent lorsque la plateforme l'exige. - **GAME-PLATFORM-019** — Une plateforme réservée n'est ni implémentée ni planifiée tant qu'une ligne ROADMAP ou un delta ne l'engage explicitement. diff --git a/docs/rules/RULES_VALIDATION_MATRIX.md b/docs/rules/RULES_VALIDATION_MATRIX.md index be0311d..67d2d76 100644 --- a/docs/rules/RULES_VALIDATION_MATRIX.md +++ b/docs/rules/RULES_VALIDATION_MATRIX.md @@ -1,5 +1,5 @@ - + # Matrice normative des commandes et validations @@ -29,11 +29,14 @@ Les commandes ciblées restent la norme pendant l'implémentation ; les gates wo | `CMD-026` | `cargo tree -p --edges normal` ou variante ciblée | — | dépendances/features modifiées ou diagnostic | selon portée | | `CMD-030` | build Desktop `--release` ciblé | gates Rust applicables | runner/distribution Desktop touché | beta | | `CMD-031` | smoke Desktop release | `CMD-030` | runtime Desktop touché | beta | -| `CMD-040` | `(cd && cargo tauri dev)` | gates Rust/frontend applicables | smoke interactif Tauri | `pre`/beta | -| `CMD-041` | `(cd && cargo tauri build)` | gates Rust/frontend applicables | packaging Tauri final/prefinal | beta/RC | +| `CMD-040` | `(cd && cargo tauri dev)` | gates Rust/frontend applicables | smoke interactif Tauri Desktop | `pre`/beta | +| `CMD-041` | `(cd && cargo tauri build)` | gates Rust/frontend applicables | packaging Tauri Desktop final/prefinal | beta/RC | | `CMD-042` | build Rust `wasm32-unknown-unknown` + `wasm-bindgen --target web` | gates Rust de l'adapter | adapter WASM/Web direct touché | `pre` | | `CMD-043` | `(cd Web/ && npm install && npm run build)` | `CMD-042` si frontend avec WASM | frontend Web direct touché | `pre` | | `CMD-044` | smoke navigateur du host Web direct | `CMD-043` | Canvas/input/responsive Web touchés | `pre`/beta | +| `CMD-045` | `(cd && cargo tauri android init)` | environnement Android/Tauri | initialisation unique de la cible Tauri Android | `pre` | +| `CMD-046` | `(cd && cargo tauri android dev)` | gates Rust/frontend applicables | smoke interactif Tauri Android | `pre`/beta | +| `CMD-047` | `(cd && cargo tauri android build)` | gates Rust/frontend applicables | packaging Tauri Android final/prefinal | beta/RC | | `CMD-050` | build Rust Android ABI ciblé | gates Rust applicables | Android/JNI/backend natif touché | pre/beta | | `CMD-051` | `(cd Android && ./gradlew ::assembleDebug)` | `CMD-050` si Rust natif change | Android/app/manifest/Java touché | pre/beta | | `CMD-052` | install + smoke AVD | `CMD-051` | Android concerné | beta | @@ -52,7 +55,7 @@ Dès que du Rust ou une dépendance Cargo change, la séquence minimale obligato `CMD-026` est ajouté lorsqu'un graphe de dépendances/features a changé ou doit être diagnostiqué ; il est omis des validations ordinaires sans changement de dépendances. -Toute commande avec changement de répertoire utilise un sous-shell, comme le montrent `CMD-040`, `CMD-041`, `CMD-043` et `CMD-051`. +Toute commande avec changement de répertoire utilise un sous-shell, comme le montrent `CMD-040`, `CMD-041`, `CMD-043`, `CMD-045` à `CMD-047` et `CMD-051`. ## Dépendances entre crates diff --git a/docs/studies/000-README.md b/docs/studies/000-README.md index 3f51af3..50656b6 100644 --- a/docs/studies/000-README.md +++ b/docs/studies/000-README.md @@ -1,5 +1,5 @@ - + # Études @@ -57,3 +57,7 @@ Ces documents étudient les POC à réaliser ; ils ne lancent encore aucune impl ## Étude de cadrage 0.3.0 - [`023-V0_3_0_PLATFORM_POC_AUDIT.md`](023-V0_3_0_PLATFORM_POC_AUDIT.md) — audit réel de la baseline `0.2.0`, requirements Snake, graphe de dépendances, choix du premier POC et sizing corrigé de `0.3.0`. + +## Étude de cadrage 0.3.1 + +- [`024-V0_3_1_TAURI_ANDROID_SNAKE_AUDIT.md`](024-V0_3_1_TAURI_ANDROID_SNAKE_AUDIT.md) — audit de la baseline `0.3.0`, réutilisation Web/WASM, référence Tauri existante, environnement Android et sizing du second host Snake. diff --git a/docs/studies/024-V0_3_1_TAURI_ANDROID_SNAKE_AUDIT.md b/docs/studies/024-V0_3_1_TAURI_ANDROID_SNAKE_AUDIT.md new file mode 100644 index 0000000..add84bb --- /dev/null +++ b/docs/studies/024-V0_3_1_TAURI_ANDROID_SNAKE_AUDIT.md @@ -0,0 +1,223 @@ + + + +# Audit v0.3.1 — second host Snake Tauri Android + +## Statut + +Étude de cadrage `0.3.1-0-pre.1`. + +Base autoritaire : archive téléchargée depuis le tag `v0.3.0` et fournie pour cette reprise. + +Cette tranche reste un gate d'audit, requirements, sizing et planification. Aucun scaffold Tauri Android Snake, aucun frontend nouveau et aucun changement de gameplay n'y sont introduits. + +## Intégrité de la baseline + +L'archive `v0.3.0` a été extraite et testée avant modification. + +Les contrôles statiques de baseline sont propres : + +```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) +``` + +La version technique racine est `0.3.0`. Aucun `Cargo.lock`, `package-lock.json`, `pnpm-lock.yaml`, `yarn.lock`, `node_modules/`, `dist/`, `target/` ou binding WASM généré n'est présent dans l'archive source. + +L'absence de `.git` est normale pour cette archive taggée et ne permet ni ne requiert d'inventer un état Git. + +## État fonctionnel hérité + +La release `0.3.0` apporte déjà les briques nécessaires au second host : + +- `game-snake-poc` porte le gameplay et reste indépendant du host ; +- `game-snake-poc-wasm` expose le runtime Snake à WebAssembly ; +- `Web/game-snake-poc` valide Canvas, clavier/pointer/touch, resize, lifecycle navigateur, assets, diagnostics frontend et provenance ; +- le runner Desktop SDL3 reste le témoin natif de non-régression ; +- les builds Web nouveaux utilisent Cargo, `wasm-bindgen` et Vite sans orchestration Python. + +Le POC Tauri Reflex historique fournit en plus une référence de structure Tauri, mais il conserve des hooks Python gelés qui ne doivent pas être copiés dans un chemin `0.3.x`. + +Son manifest contient déjà le triplet `crate-type = ["staticlib", "cdylib", "rlib"]`, compatible avec la préparation mobile Tauri. En revanche son `run()` reste un point d'entrée Desktop et n'est pas annoté `#[cfg_attr(mobile, tauri::mobile_entry_point)]`. La nouvelle app Snake doit donc reprendre la séparation de fichiers, pas ce détail Desktop : le `run()` possédé par `tauri.rs` devra être le point d'entrée mobile et être réexporté par la façade `lib.rs`. + +Le manifest Reflex déclare aussi `engine-v1-platform-api`, alors que son code source Tauri ne le consomme pas directement. Cette dépendance ne doit pas être copiée par mimétisme dans la nouvelle app ; la provenance Snake appartient déjà à l'adapter WASM tant qu'aucune responsabilité backend Tauri ne justifie ce lien. + +## Référence KSP Desk + +L'archive de référence KSP `khadhroony-solana-project-v0.3.15.zip` est bien présente dans la bibliothèque du projet, mais son export binaire vers l'environnement de travail n'est pas autorisé par la bibliothèque. Son contenu intégral n'est donc pas présenté comme audité ici. + +Les éléments KSP indexés accessibles confirment néanmoins la convention recherchée : + +- `src/tauri.rs` concentre l'assemblage Tauri et le lifecycle de fenêtre ; +- des modules propriétaires tels que `app_state.rs`, `route_runtime.rs` et `frontend_logging.rs` portent leur logique au lieu de gonfler `tauri.rs` ; +- les diagnostics frontend sont routés vers des cibles `tracing` structurées. + +Le modèle normatif de `games.sasedev` reste la source de vérité : `lib.rs` façade/reexports, `tauri.rs` assemblage et pont Web/Rust, modules propriétaires séparés. + +## Réutilisation attendue du host Web + +### Réutilisé sans changement de responsabilité + +`game-snake-poc` reste inchangé comme source de vérité du gameplay. + +Les assets canoniques sous `assets/common/` et `assets/game-snake-poc/` restent les mêmes ; le host Tauri doit les embarquer ou les copier au build, pas créer une seconde source. + +Le contrat sémantique d'entrée du jeu reste le même. Les boutons tactiles et éventuelles entrées clavier du WebView convergent vers les mêmes actions Snake. + +### Réutilisé avec adaptation de host + +Le Canvas, la session fixed-step, la projection de scène et une grande partie du shell Vite/TypeScript du host Web sont des références directes pour le frontend Tauri. + +La détection `DeviceClass` et `InputProfile` peut être reprise, mais les dimensions fixes de provenance changent : + +```text +Web direct = Web / Wasm / Browser +Tauri Android = Android / Wasm / TauriWebView +``` + +Le lifecycle navigateur `visibilitychange/pagehide/pageshow` n'est pas copié comme seul contrat mobile. Le host Tauri Android doit tester le comportement réel lors de pause/reprise, changement d'orientation, background/foreground et fermeture/navigation système. + +Le logging frontend Web direct n'est pas réutilisé tel quel : Tauri doit utiliser le bridge `@fltsci/tauri-plugin-tracing` vers `tauri-plugin-tracing`/`tracing`. + +### Dépendances frontend à ne pas copier mécaniquement + +Bootstrap, Bootswatch, Font Awesome et Sass peuvent être repris si le shell Tauri conserve réellement la même UI. + +SimpleBar et `resize-observer-polyfill` restent des dépendances du shell Web direct ; les règles interdisent de les faire devenir des dépendances Tauri par simple copie. Elles ne seront ajoutées que si le layout Android Tauri démontre leur nécessité. + +## Point de friction principal : provenance de l'adapter WASM + +`game-snake-poc-wasm` est réutilisable pour le gameplay et le rendu, mais son état `0.3.0` fixe actuellement `PlatformFamily::Web` et `RuntimeHost::Browser` dans son constructeur et dans `configure_runtime_provenance`. + +Il ne peut donc pas décrire correctement un WebView Tauri Android sans modification minimale. + +La direction retenue est de généraliser uniquement la configuration de provenance du host dans l'adapter existant, sans dupliquer le bridge et sans créer une abstraction WebView commune prématurée. Le même adapter doit pouvoir représenter au moins : + +```text +Web / Browser / Wasm +Android / TauriWebView / Wasm +``` + +Le nom `PlatformFamily::Android` est conservé. `Mobile` reste une famille conceptuelle d'architecture et ne justifie pas un renommage de l'API V1 ni l'introduction d'iOS dans `0.3.1`. + +## Structure cible de l'application + +Le second host sera une nouvelle crate : + +```text +crates/apps/game-snake-poc-tauri/ +``` + +La crate est génériquement nommée Tauri afin de pouvoir accueillir ultérieurement le host Desktop prévu en `0.3.2`, mais `0.3.1` n'en valide que la cible Android. + +Structure minimale visée : + +```text +crates/apps/game-snake-poc-tauri/ +├── Cargo.toml +├── build.rs +├── tauri.conf.json +├── capabilities/ +├── frontend/ +├── src/ +│ ├── lib.rs +│ ├── main.rs +│ ├── runtime.rs +│ └── tauri.rs +├── README.md +└── USAGE.md +``` + +`lib.rs` reste une façade. `tauri.rs` assemble builder/plugins/commands et délègue aux modules propriétaires. Une responsabilité supplémentaire devient un module dédié plutôt qu'une collection de helpers dans `tauri.rs`. + +Le `README.md` est requis pour expliquer frontières et architecture. `USAGE.md` est également retenu car le host Android Tauri possède des prérequis SDK/JDK/NDK, des commandes de device/AVD et des smokes non triviaux. + +## Build et commandes Tauri Android + +La revue des règles a trouvé un défaut de cible : les commandes Tauri existantes `cargo tauri dev/build` correspondent au chemin Desktop alors que le nouveau POC est mobile Android. + +La règle est corrigée pour réserver à Android : + +```text +cargo tauri android init +cargo tauri android dev +cargo tauri android build +``` + +Le projet mobile généré par Tauri est traité comme partie du host Android lorsqu'il est requis par l'outil ; son contenu exact sera créé par l'outil Tauri dans la tranche d'implémentation, pas fabriqué à la main pendant le cadrage. + +Aucun nouveau script Python de build n'est autorisé. Le frontend Vite/TypeScript et la génération WASM doivent rester possédés par les hooks Tauri et les outils natifs Cargo/`wasm-bindgen`/Tauri. + +## Environnement Android : confirmé et à reconfirmer + +L'historique du dépôt prouve des validations récentes de l'autre chemin Android SDL3 : NDK, ADB, AVD API 36 et appareil ARM64 réel ont déjà été utilisés avec succès pendant `0.1.0`. + +La release `0.3.0` prouve également l'usage récent de Cargo, `wasm32-unknown-unknown`, `wasm-bindgen`, Node/npm et Vite. + +Ces validations historiques ne prouvent pas l'état présent du toolchain Tauri Android. Avant `0-pre.2`, l'utilisateur doit fournir un inventaire frais de : + +- `cargo tauri --version` ; +- targets Rust Android installés ; +- Java/JDK et `JAVA_HOME` ; +- `ANDROID_HOME` ; +- NDK et `NDK_HOME` ; +- `adb version` et devices visibles ; +- AVD disponibles ; +- Node/npm et `wasm-bindgen`. + +Les prérequis Tauri 2 actuels pour Android comprennent Android Studio/tooling SDK, NDK, JDK et les targets Rust Android. Cette tranche ne suppose pas qu'ils sont tous encore configurés seulement parce que l'Android SDL3 historique fonctionnait. + +## Risques à tester explicitement + +- compatibilité réelle de `tauri-plugin-tracing` et du bridge frontend sur Android ; le package `0.3.x` est bien la référence actuelle du projet, mais le support mobile doit être prouvé par compilation/smoke plutôt que supposé ; +- lifecycle background/foreground et suspension du WebView ; +- distinction entre une sortie applicative Tauri, qui passe par `EngineGame::quit_requested`, et le Back système Android, qui ne doit pas être consommé artificiellement ; +- propagation correcte des dimensions logiques et du `devicePixelRatio` après rotation/resize ; +- chargement des assets embarqués sans dépendre du serveur Vite en build Android ; +- pipeline WASM sans script Python ; +- séparation claire entre Android SDL3 existant sous `Android/` et Tauri Android généré par la crate Tauri ; +- absence de dépendances Web-only recopiées par inertie ; +- output des builds et caches hors racine selon `GAME-BUILD-001`. + +## Décisions de cadrage + +Retenu pour `0.3.1` : + +- une seule nouvelle app `game-snake-poc-tauri` ; +- Android uniquement comme cible validée dans cette version ; +- réutilisation du même `game-snake-poc-wasm` après généralisation minimale de provenance ; +- réutilisation sélective du frontend Web ; +- structure Rust Tauri conforme aux apps Desk : façade, assemblage, modules propriétaires ; +- tracing Tauri de bout en bout ; +- pas de nouveau framework commun tant qu'une duplication réelle entre Web direct et Tauri WebView n'est pas mesurée ; +- aucun orchestrateur Python nouveau ou repris. + +Reporté : + +- Tauri Desktop Snake comme produit validé, vers `0.3.2` ; +- abstraction WebView commune, sauf duplication réellement prouvée ; +- iOS ; +- Android SDL3 multi-ABI supplémentaire ; +- ads, billing, auth, réseau realtime et Uroburas. + +## Sizing + +Le scope complet est trop risqué pour être comprimé dans une seule prerelease d'implémentation. Le découpage retenu est : + +```text +0-pre.1 audit / règles / requirements / environnement / plan +0-pre.2 scaffold Tauri Android + pipeline natif + bridge minimal vers Snake WASM +0-pre.3 Canvas / input / assets / shell réutilisé du Web +0-pre.4 lifecycle / provenance / tracing / Back + smoke mobile +0-pre.5 conditionnel : extraction commune seulement si duplication réelle +2-beta.1 gate large + packaging Android + AVD/appareil selon disponibilité +2-beta.2 consolidation documentaire si nécessaire +3-rc.1 candidate gelée et reproductibilité +0.3.1 promotion stable mécanique +``` + +Une tranche peut être scindée si un défaut outillage réel l'impose. `0-pre.5` est supprimé s'il n'existe aucune extraction justifiée. diff --git a/prompts/003-V0_3_1_START_PROMPT.md b/prompts/003-V0_3_1_START_PROMPT.md index 8ac2e1f..01788e1 100644 --- a/prompts/003-V0_3_1_START_PROMPT.md +++ b/prompts/003-V0_3_1_START_PROMPT.md @@ -1,5 +1,5 @@ - + # Prompt de démarrage `0.3.1` — second host Snake Tauri Android @@ -281,13 +281,13 @@ Pour une application Tauri, `npm` sert seulement à gérer les dépendances fron Le smoke courant utilise : ```bash -(cd && cargo tauri dev) +(cd && cargo tauri android dev) ``` Le packaging est réservé aux phases finales prévues par le plan : ```bash -(cd && cargo tauri build) +(cd && cargo tauri android build) ``` Ne pas traiter le host Tauri comme le host navigateur direct de `0.3.0` : le mode de lancement, le packaging, les permissions et les smokes sont différents. @@ -417,7 +417,7 @@ Toute commande nécessitant un changement de répertoire est englobée dans un s (cd && ) ``` -Pour Tauri, utiliser `cargo tauri dev` pour les smokes et réserver `cargo tauri build` aux phases finales de packaging ; `npm` n'est utilisé directement que pour gérer les dépendances frontend. +Pour Tauri, utiliser `cargo tauri android dev` pour les smokes Android et réserver `cargo tauri android build` aux phases finales de packaging Android ; `npm` n'est utilisé directement que pour gérer les dépendances frontend. ## 13. Qui exécute quoi @@ -429,8 +429,8 @@ Les validations de build/runtime restent côté utilisateur : cargo check workspace + Clippy workspace strict lorsqu'un delta touche Rust/dépendances tests cargo ciblés par défaut test workspace complet seulement aux jalons planifiés/portées incertaines -(cd && cargo tauri dev) pour les smokes Tauri -(cd && cargo tauri build) pour les validations finales de packaging Tauri +(cd && cargo tauri android dev) pour les smokes Tauri +(cd && cargo tauri android build) pour les validations finales de packaging Tauri Gradle/SDK/NDK lorsque le chemin Tauri les invoque installation émulateur/appareil smoke mobile @@ -482,8 +482,8 @@ Sinon omettre la tranche. ### `2-beta.1` — validation large - workspace complet ; -- `(cd && cargo tauri build)` pour le packaging Tauri Android ; -- smoke via `(cd && cargo tauri dev)` puis émulateur/appareil disponible ; +- `(cd && cargo tauri android build)` pour le packaging Tauri Android ; +- smoke via `(cd && cargo tauri android dev)` puis émulateur/appareil disponible ; - non-régression Web direct ; - non-régression Desktop SDL3 lorsque nécessaire ; - vérification dépendances/package/distribution.