v0.1.4-pre.004

2026-08-16 10:40:23 +02:00
parent fa6d4e1039
commit fcc1e9913d
20 changed files with 633 additions and 17 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,5 @@
 # file: .gitignore
-# version: 2
+# version: 3

 # Rust build artifacts
 # /target/ # target is outside.
@@ -16,6 +16,8 @@ pnpm-debug.log*
 # Node / frontend dependencies and generated artifacts
 **/node_modules/
 **/dist/
+bindings/
+gen/
 package-lock.json
 pnpm-lock.yaml
 yarn.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,12 +1,12 @@
 # file: Cargo.toml
-# version: 64
+# version: 65

 [workspace]
 resolver = "3"
-members = ["crates/ksp-config-lib", "crates/ksp-core-lib", "crates/ksp-logging-lib"]
+members = ["crates/ksp-app-config-desk", "crates/ksp-config-lib", "crates/ksp-core-lib", "crates/ksp-logging-lib"]

 [workspace.package]
-version = "0.1.4-pre.3"
+version = "0.1.4-pre.4"
 edition = "2024"
 license = "MIT"
 repository = "https://git.sasedev.com/Sasedev/khadhroony-solana-project"
@@ -14,6 +14,7 @@ authors = ["SinuS von SifriduS <sinus@sasedev.net>"]
 publish = false

 [workspace.dependencies]
+fs2 = { version = "^0.4" }
 serde = { version = "^1.0", features = ["derive"] }
 serde_json = { version = "^1.0" }
 jsonschema = { version = "^0.49", default-features = false }
@@ -22,6 +23,8 @@ tracing = { version = "^0.1", default-features = false, features = ["std"] }
 tracing-subscriber = { version = "^0.3", default-features = false, features = ["fmt", "json", "ansi"] }
 tracing-appender = { version = "^0.2", default-features = false }
 tokio = { version = "^1.53", default-features = false, features = ["rt", "rt-multi-thread", "macros"] }
+tauri = { version = "^2.11" }
+tauri-build = { version = "^2.6" }

 [workspace.lints.rust]
 missing_docs = "warn"
--- a/crates/ksp-app-config-desk/Cargo.toml
+++ b/crates/ksp-app-config-desk/Cargo.toml
@@ -0,0 +1,30 @@
+# file: crates/ksp-app-config-desk/Cargo.toml
+# version: 1
+
+[package]
+name = "ksp-app-config-desk"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+publish.workspace = true
+
+[lib]
+name = "ksp_app_config_desk_lib"
+path = "src/lib.rs"
+crate-type = ["staticlib", "cdylib", "rlib"]
+
+[[bin]]
+name = "ksp-app-config-desk"
+path = "src/main.rs"
+
+[build-dependencies]
+tauri-build.workspace = true
+
+[dependencies]
+fs2.workspace = true
+ksp-core-lib = { path = "../ksp-core-lib" }
+tauri.workspace = true
+
+[lints]
+workspace = true
--- a/crates/ksp-app-config-desk/README.md
+++ b/crates/ksp-app-config-desk/README.md
@@ -0,0 +1,55 @@
+<!-- file: crates/ksp-app-config-desk/README.md -->
+<!-- version: 1 -->
+
+# `ksp-app-config-desk`
+
+`ksp-app-config-desk` est l'application desktop spécialisée de management et de validation de la configuration KSP.
+
+La crate est un package Tauri mixte :
+
+```text
+package : ksp-app-config-desk
+lib     : ksp_app_config_desk_lib
+bin     : ksp-app-config-desk
+```
+
+## Responsabilités
+
+L'application restera une couche d'interface/composition. Les responsabilités de parsing, validation, profils, environnement, `.env`, secrets et persistence restent dans `ksp-config-lib`; le runtime Logging restera possédé par `ksp-logging-lib`.
+
+La première tranche de squelette établit uniquement :
+
+- le membre workspace Rust ;
+- le couple `lib` + `bin` ;
+- le verrou single-instance ;
+- l'assemblage Tauri minimal dans `src/tauri.rs` ;
+- les fenêtres `splash` et `main` ;
+- les capabilities initiales ;
+- l'icône de référence reprise du gabarit desktop éprouvé ;
+- le port de développement réservé `1430`, avec `1431` réservé au HMR Vite ;
+- le répertoire frontend cible `frontend/`, dont `frontend/ts/` et `frontend/ts/bindings/`.
+
+Le frontend Vite/TypeScript/SCSS et les dépendances npm sont introduits dans la tranche suivante. Tant que cette tranche n'est pas appliquée, `cargo tauri dev` n'est pas un scénario de validation attendu de ce squelette.
+
+## Artefacts frontend
+
+Les artefacts frontend construits ne doivent pas être versionnés. `tauri.conf.json` fixe dès maintenant la destination contractuelle :
+
+```text
+../../builds/khadhroony-solana-project/ksp-app-config-desk/dist
+```
+
+`vite.config.ts` utilisera la même destination lors de son introduction.
+
+Les commandes npm servent uniquement à installer/mettre à jour les dépendances. Le cycle normal de développement/build de l'application passe par Tauri, qui déclenche les scripts frontend déclarés dans sa configuration.
+
+## Ports desktop
+
+KSP réserve des couples de ports distincts par application desk. `ksp-app-config-desk`, première application, utilise :
+
+```text
+Vite HTTP : 1430
+Vite HMR  : 1431
+```
+
+Les applications desk suivantes incrémentent le couple de deux ports afin de pouvoir fonctionner simultanément sans collision.
--- a/crates/ksp-app-config-desk/TODO.md
+++ b/crates/ksp-app-config-desk/TODO.md
@@ -0,0 +1,16 @@
+<!-- file: crates/ksp-app-config-desk/TODO.md -->
+<!-- version: 1 -->
+
+# TODO `ksp-app-config-desk`
+
+Les éléments suivants appartiennent aux prochaines tranches de `0.1.4` :
+
+- ajouter le gabarit frontend Vite/TypeScript/SCSS sous `frontend/` ;
+- ajouter `package.json`, `tsconfig.json` et `vite.config.ts` ;
+- réserver strictement `1430` pour Vite et `1431` pour HMR ;
+- introduire SimpleBar, `resize-observer-polyfill`, Bootstrap et Font Awesome selon le gabarit retenu ;
+- intégrer `tauri-plugin-tracing` et `@fltsci/tauri-plugin-tracing` ;
+- introduire les DTO TS-RS au premier contrat Tauri réel, avec bindings générés sous `frontend/ts/bindings/` ;
+- introduire `AppState`, Config et l'ownership de `LoggingGuard` ;
+- développer les panneaux Documents, Profils, Environnement/`.env`, Secrets et Logging ;
+- démontrer le hot reload Logging et le panneau de test de routage.
--- a/crates/ksp-app-config-desk/USAGE.md
+++ b/crates/ksp-app-config-desk/USAGE.md
@@ -0,0 +1,34 @@
+<!-- file: crates/ksp-app-config-desk/USAGE.md -->
+<!-- version: 1 -->
+
+# Utilisation de `ksp-app-config-desk`
+
+## État actuel
+
+La tranche `0.1.4-pre.004` introduit le squelette Rust/Tauri uniquement. Les fenêtres frontend ne deviennent exécutables qu'après l'ajout du gabarit Vite/TypeScript prévu par la tranche suivante.
+
+## Entrée binaire
+
+Le binaire `ksp-app-config-desk` :
+
+1. acquiert un verrou single-instance dans le répertoire temporaire du système ;
+2. collecte les arguments de processus sans lire directement de variable `KSP_*`/`KSPB_*` ;
+3. appelle `ksp_app_config_desk_lib::run()` ;
+4. convertit explicitement le résultat en `ExitCode`.
+
+Les arguments Config `--cfgpath`, `--schemapath` et `--filemap` seront consommés par les APIs `ksp-config-lib` dans la tranche de bootstrap applicatif prévue plus loin ; le binaire ne doit pas en réimplémenter le parsing.
+
+## Fenêtres réservées
+
+Deux fenêtres sont déjà déclarées dans `tauri.conf.json` :
+
+- `splash` : lifecycle de démarrage commun ;
+- `main` : shell de management Config.
+
+Leur contenu HTML/TypeScript est ajouté avec le gabarit frontend.
+
+## Développement frontend
+
+Le cycle normal utilisera `cargo tauri dev`. Tauri déclenchera alors `npm run dev` via `beforeDevCommand` et chargera le serveur Vite sur le port `1430`.
+
+Les commandes npm directes sont réservées à la gestion des dépendances (`npm i -D ...` selon la politique du projet), et non au lancement quotidien de l'application.
--- a/crates/ksp-app-config-desk/build.rs
+++ b/crates/ksp-app-config-desk/build.rs
@@ -0,0 +1,12 @@
+// file: crates/ksp-app-config-desk/build.rs
+// version: 1
+
+//! Build script for the KSP configuration desktop application.
+
+#![forbid(unsafe_code)]
+#![deny(unreachable_pub)]
+#![warn(missing_docs)]
+
+fn main() {
+    tauri_build::build()
+}
--- a/crates/ksp-app-config-desk/capabilities/default.json
+++ b/crates/ksp-app-config-desk/capabilities/default.json
@@ -0,0 +1,12 @@
+{
+    "$schema": "../gen/schemas/desktop-schema.json",
+    "identifier": "default",
+    "description": "Default capability for KSP Config Desk",
+    "windows": [
+        "splash",
+        "main"
+    ],
+    "permissions": [
+        "core:default"
+    ]
+}
--- a/crates/ksp-app-config-desk/icons/favicon.ico
+++ b/crates/ksp-app-config-desk/icons/favicon.ico
--- a/crates/ksp-app-config-desk/icons/favicon.png
+++ b/crates/ksp-app-config-desk/icons/favicon.png
--- a/crates/ksp-app-config-desk/src/errors.rs
+++ b/crates/ksp-app-config-desk/src/errors.rs
@@ -0,0 +1,7 @@
+// file: crates/ksp-app-config-desk/src/errors.rs
+// version: 1
+
+//! Application-local error codes for the configuration desktop shell.
+
+/// Tauri runtime assembly or execution failed.
+pub(crate) const ERROR_CODE_TAURI_RUNTIME_FAILED: ksp_core_lib::ErrorCode = ksp_core_lib::ErrorCode::new("config_desk", "tauri_runtime_failed");
--- a/crates/ksp-app-config-desk/src/lib.rs
+++ b/crates/ksp-app-config-desk/src/lib.rs
@@ -0,0 +1,16 @@
+// file: crates/ksp-app-config-desk/src/lib.rs
+// version: 1
+
+//! Tauri desktop application for managing and validating KSP configuration.
+
+#![forbid(unsafe_code)]
+#![deny(unreachable_pub)]
+#![warn(missing_docs)]
+
+mod errors;
+mod tauri;
+
+/// Runs the KSP configuration desktop application.
+pub use self::tauri::run;
+
+pub(crate) use self::errors::ERROR_CODE_TAURI_RUNTIME_FAILED;
--- a/crates/ksp-app-config-desk/src/main.rs
+++ b/crates/ksp-app-config-desk/src/main.rs
@@ -0,0 +1,41 @@
+// file: crates/ksp-app-config-desk/src/main.rs
+// version: 1
+
+//! Binary entry point for the KSP configuration desktop application.
+
+#![forbid(unsafe_code)]
+#![deny(unreachable_pub)]
+#![warn(missing_docs)]
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+use fs2::FileExt; // rust-rules: trait-import
+
+fn main() -> std::process::ExitCode {
+    let mut lock_path = std::env::temp_dir();
+    lock_path.push("com_sasedev_ksp_app_config_desk.lock");
+    let lock_file = match std::fs::OpenOptions::new().read(true).write(true).create(true).open(&lock_path) {
+        std::result::Result::Ok(file) => file,
+        std::result::Result::Err(error) => {
+            eprintln!("cannot create application lock '{}': {error}", lock_path.display());
+            return std::process::ExitCode::FAILURE;
+        },
+    };
+    if let std::result::Result::Err(error) = lock_file.try_lock_exclusive() {
+        if error.kind() == std::io::ErrorKind::WouldBlock {
+            eprintln!("another ksp-app-config-desk instance is already running");
+            return std::process::ExitCode::FAILURE;
+        }
+        eprintln!("cannot acquire application lock '{}': {error}", lock_path.display());
+        return std::process::ExitCode::FAILURE;
+    }
+    let _lock_file = lock_file;
+    let arguments = std::env::args_os().collect::<std::vec::Vec<std::ffi::OsString>>();
+    let run_result = ksp_app_config_desk_lib::run(arguments.as_slice());
+    return match run_result {
+        std::result::Result::Ok(()) => std::process::ExitCode::SUCCESS,
+        std::result::Result::Err(error) => {
+            eprintln!("application error: {error}");
+            std::process::ExitCode::FAILURE
+        },
+    };
+}
--- a/crates/ksp-app-config-desk/src/tauri.rs
+++ b/crates/ksp-app-config-desk/src/tauri.rs
@@ -0,0 +1,33 @@
+// file: crates/ksp-app-config-desk/src/tauri.rs
+// version: 1
+
+//! Tauri runtime assembly for the KSP configuration desktop application.
+
+use tauri::Manager; // rust-rules: trait-import
+
+/// Runs the configuration desktop application.
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run(_arguments: &[std::ffi::OsString]) -> ksp_core_lib::Result<()> {
+    let mut builder = tauri::Builder::default();
+    builder = configure_setup(builder);
+    let run_result = builder.run(tauri::generate_context!());
+    return match run_result {
+        std::result::Result::Ok(()) => std::result::Result::Ok(()),
+        std::result::Result::Err(error) => std::result::Result::Err(
+            ksp_core_lib::Error::new(crate::ERROR_CODE_TAURI_RUNTIME_FAILED, "Cannot run KSP Config Desk Tauri runtime")
+                .with_context("tauri_error", error.to_string()),
+        ),
+    };
+}
+
+fn configure_setup(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<tauri::Wry> {
+    return builder.setup(|app| {
+        if app.get_webview_window("splash").is_none() {
+            return std::result::Result::Err(std::boxed::Box::new(std::io::Error::new(std::io::ErrorKind::NotFound, "splash window is missing")));
+        }
+        if app.get_webview_window("main").is_none() {
+            return std::result::Result::Err(std::boxed::Box::new(std::io::Error::new(std::io::ErrorKind::NotFound, "main window is missing")));
+        }
+        return std::result::Result::Ok(());
+    });
+}
--- a/crates/ksp-app-config-desk/tauri.conf.json
+++ b/crates/ksp-app-config-desk/tauri.conf.json
@@ -0,0 +1,50 @@
+{
+    "$schema": "https://schema.tauri.app/config/2",
+    "productName": "KSP Config Desk",
+    "version": "0.1.4",
+    "identifier": "com.sasedev.ksp-app-config-desk",
+    "build": {
+        "beforeDevCommand": "npm run dev",
+        "devUrl": "http://localhost:1430",
+        "beforeBuildCommand": "npm run build",
+        "frontendDist": "../../builds/khadhroony-solana-project/ksp-app-config-desk/dist"
+    },
+    "app": {
+        "windows": [
+            {
+                "label": "splash",
+                "url": "splash.html",
+                "title": "Chargement — KSP Config Desk",
+                "width": 960,
+                "height": 637,
+                "resizable": false,
+                "decorations": false,
+                "transparent": true,
+                "center": true,
+                "alwaysOnTop": true
+            },
+            {
+                "label": "main",
+                "url": "main.html",
+                "title": "KSP Config Desk",
+                "width": 1500,
+                "height": 960,
+                "minWidth": 1024,
+                "minHeight": 768,
+                "center": true,
+                "visible": false
+            }
+        ],
+        "security": {
+            "csp": null
+        }
+    },
+    "bundle": {
+        "active": true,
+        "targets": "all",
+        "icon": [
+            "icons/favicon.png",
+            "icons/favicon.ico"
+        ]
+    }
+}
--- a/crates/ksp-app-config-desk/tests/public_api.rs
+++ b/crates/ksp-app-config-desk/tests/public_api.rs
@@ -0,0 +1,14 @@
+// file: crates/ksp-app-config-desk/tests/public_api.rs
+// version: 1
+
+//! Public API checks for the KSP configuration desktop application library.
+
+#![forbid(unsafe_code)]
+#![deny(unreachable_pub)]
+#![warn(missing_docs)]
+
+#[test]
+fn run_entry_point_is_available_from_crate_root() {
+    let run_entry_point: fn(&[std::ffi::OsString]) -> ksp_core_lib::Result<()> = ksp_app_config_desk_lib::run;
+    assert_eq!(std::mem::size_of_val(&run_entry_point), std::mem::size_of::<fn(&[std::ffi::OsString]) -> ksp_core_lib::Result<()>>());
+}
--- a/deltas/0.1.4/pre.003.md
+++ b/deltas/0.1.4/pre.003.md
@@ -174,7 +174,7 @@ deltas/0.1.4/pre.003.md
 ## Fichiers modifiés

 | Fichier                                          | Version précédente | Nouvelle version |
-| ---------------------------------------------- | ------------------: | ---------------: |
+|--------------------------------------------------|-------------------:|-----------------:|
 | `Cargo.toml`                                     |                 63 |               64 |
 | `crates/ksp-config-lib/src/document.rs`          |                  4 |                5 |
 | `crates/ksp-config-lib/src/management.rs`        |                  1 |                2 |
--- a/deltas/0.1.4/pre.004.md
+++ b/deltas/0.1.4/pre.004.md
@@ -0,0 +1,259 @@
+<!-- file: deltas/0.1.4/pre.004.md -->
+<!-- version: 1 -->
+
+# Delta 0.1.4-pre.004 — squelette Rust/Tauri de `ksp-app-config-desk`
+
+## Base requise
+
+```text
+0.1.4-pre.003
+workspace.package.version = "0.1.4-pre.3"
+```
+
+`pre.003` est considéré comme validé et commité. Les validations locales fournies avant cette tranche ont réussi : `cargo fmt --all`, `cargo check --workspace`, `cargo clippy --workspace --all-targets`, `cargo test -p ksp-config-lib` et `cargo tree -p ksp-config-lib`.
+
+## Objectif
+
+Créer la première application Tauri KSP sans commencer encore ses panneaux fonctionnels ni son frontend complet.
+
+Cette tranche établit les contrats structurels qu'il serait coûteux de modifier plus tard :
+
+- crate workspace `crates/ksp-app-config-desk` ;
+- package Rust mixte `lib` + `bin` ;
+- `main.rs` launcher mince avec verrou single-instance ;
+- `tauri.rs` propriétaire du runtime Tauri ;
+- builder Tauri configuré par étapes courtes ;
+- fenêtres `splash` et `main` ;
+- capabilities initiales ;
+- icône de référence issue du gabarit bot3 ;
+- destination frontend externe ;
+- premier couple de ports desk `1430/1431` ;
+- conventions `frontend/ts`, `frontend/sass` et bindings TS-RS.
+
+Le frontend Vite/TypeScript/SCSS et les dépendances npm restent réservés à `pre.005`.
+
+## Version Cargo
+
+`workspace.package.version` passe de :
+
+```text
+0.1.4-pre.3
+```
+
+à :
+
+```text
+0.1.4-pre.4
+```
+
+L'identifiant de livraison est :
+
+```text
+0.1.4-pre.004
+```
+
+## 1. Nouveau membre workspace
+
+Le workspace contient désormais :
+
+```text
+crates/ksp-app-config-desk
+```
+
+Le package expose deux cibles distinctes :
+
+```text
+package : ksp-app-config-desk
+lib     : ksp_app_config_desk_lib
+bin     : ksp-app-config-desk
+```
+
+La bibliothèque utilise les crate types Tauri usuels `staticlib`, `cdylib` et `rlib` afin de conserver le gabarit compatible desktop/mobile sans déplacer la logique applicative dans le binaire.
+
+## 2. Dépendances Rust introduites
+
+Les versions ont été revérifiées au moment de cette tranche :
+
+| Dépendance    | Version auditée | Contrainte workspace | Usage immédiat             |
+| ------------- | --------------: | -------------------: | -------------------------- |
+| `tauri`       |        `2.11.5` |              `^2.11` | runtime/application        |
+| `tauri-build` |         `2.6.3` |               `^2.6` | build script Tauri         |
+| `fs2`         |         `0.4.3` |               `^0.4` | verrou single-instance     |
+
+Les contraintes sont déclarées sous `[workspace.dependencies]`; la crate applicative les consomme avec `.workspace = true`.
+
+`ksp-core-lib` est la seule dépendance KSP immédiate de cette tranche, pour `Result`/`ErrorCode`/`Error`. `ksp-config-lib`, `ksp-logging-lib`, `tauri-plugin-tracing`, `ts-rs` et les dépendances frontend ne sont pas ajoutés prématurément : ils entreront lorsque leurs premiers usages réels seront développés.
+
+## 3. Launcher `main.rs`
+
+`main.rs` reste volontairement mince :
+
+1. construit un lockfile dans le répertoire temporaire système ;
+2. acquiert un lock exclusif non bloquant via `fs2` ;
+3. refuse une seconde instance ;
+4. collecte `std::env::args_os()` ;
+5. appelle `ksp_app_config_desk_lib::run(arguments)` ;
+6. convertit explicitement le résultat en `ExitCode`.
+
+Le launcher ne lit aucune variable `KSP_*`/`KSPB_*` et ne parse pas Config lui-même. Les diagnostics précédant l'initialisation future de Logging restent limités à `stderr`.
+
+## 4. Frontière `tauri.rs`
+
+`tauri.rs` possède dès maintenant `run()` et le `tauri::Builder`.
+
+La construction suit la convention KSP décidée pendant `pre.001` :
+
+```text
+let mut builder = tauri::Builder::default();
+builder = configure_setup(builder);
+...
+```
+
+Aucune longue chaîne monolithique n'est introduite. Les prochains plugins, states, setups et handlers seront ajoutés par étapes courtes/réassignées ou helpers ciblés.
+
+Le setup initial vérifie uniquement que les fenêtres déclarées `splash` et `main` existent. Il n'existe encore aucune commande Tauri ; lorsqu'elles apparaîtront, leurs annotations `#[tauri::command]` resteront centralisées dans ce module.
+
+Une erreur runtime Tauri est convertie vers le type commun `ksp_core_lib::Error` avec le code applicatif `config_desk.tauri_runtime_failed`.
+
+## 5. Configuration Tauri
+
+`tauri.conf.json` déclare :
+
+- produit `KSP Config Desk` ;
+- identifiant `com.sasedev.ksp-app-config-desk` ;
+- version applicative `0.1.4` ;
+- fenêtre `splash` cachant le shell pendant le lifecycle de démarrage ;
+- fenêtre `main` initialement invisible ;
+- icônes `favicon.png` et `favicon.ico` reprises du gabarit bot3 ;
+- capability initiale `core:default` pour `splash` et `main`.
+
+Le plugin tracing n'est volontairement pas déclaré dans cette tranche ; son couple Rust/frontend est introduit avec le gabarit frontend de `pre.005`.
+
+## 6. Destination frontend et ports
+
+La destination de build est fixée dès maintenant à :
+
+```text
+../../builds/khadhroony-solana-project/ksp-app-config-desk/dist
+```
+
+`tauri.conf.json` l'utilise comme `build.frontendDist`. `vite.config.ts` utilisera la même valeur comme `build.outDir` à partir de `pre.005`.
+
+Le premier couple de ports desk est réservé :
+
+| Usage     | Port |
+| --------- | ---: |
+| Vite HTTP | 1430 |
+| Vite HMR  | 1431 |
+
+Les futures applications desk progressent par paires `1432/1433`, `1434/1435`, etc. `pre.005` configurera Vite avec port strict afin qu'une collision échoue explicitement.
+
+## 7. Convention frontend/TS-RS fixée
+
+La structure cible reprend/refond le modèle bot3 :
+
+```text
+frontend/
+├── ts/
+│   └── bindings/
+└── sass/
+```
+
+Les bindings TS-RS seront générés sous :
+
+```text
+frontend/ts/bindings/ksp_app_config_desk/...
+```
+
+Ils resteront générés/non versionnés. `ts-rs` n'est pas encore ajouté car aucun DTO Tauri n'existe dans cette tranche.
+
+La règle npm est également formalisée : npm sert directement à installer/mettre à jour les dépendances avec `npm i -D ...`; le lancement normal se fait via Tauri, qui exécute les hooks `npm run dev` et `npm run build`. Les lockfiles frontend restent ignorés.
+
+## 8. Règles KSP complétées
+
+`docs/rules/RULES_KSP.md` ajoute :
+
+- `KSP-APP-022` — builder Tauri progressif ;
+- `KSP-APP-023` — layout `frontend/ts`, `frontend/sass`, bindings TS-RS générés ;
+- `KSP-APP-024` — couples de ports desk uniques à partir de `1430/1431` ;
+- `KSP-APP-025` — npm réservé à la gestion directe des dépendances, cycle dev/build piloté par Tauri.
+
+Le plan actif passe en version 5 et enregistre les mêmes décisions pour les tranches suivantes.
+
+## 9. Générés ignorés
+
+`.gitignore` ajoute explicitement :
+
+```text
+bindings/
+gen/
+```
+
+afin de couvrir les bindings TS-RS et schemas/capabilities générés par Tauri.
+
+## 10. Tests
+
+Un premier test d'intégration `tests/public_api.rs` vérifie que la fonction publique :
+
+```rust
+ksp_app_config_desk_lib::run
+```
+
+est accessible avec la signature attendue sans lancer le runtime graphique.
+
+Aucun test frontend n'est attendu avant `pre.005`.
+
+## 11. Fichiers ajoutés/modifiés
+
+| Fichier                                                | Action  |
+|--------------------------------------------------------|:-------:|
+| `.gitignore`                                           | modifié |
+| `Cargo.toml`                                           | modifié |
+| `docs/plans/006-V0_1_4_CONFIG_DESKTOP_PLAN.md`         | modifié |
+| `docs/rules/RULES_KSP.md`                              | modifié |
+| `crates/ksp-app-config-desk/Cargo.toml`                | ajouté  |
+| `crates/ksp-app-config-desk/README.md`                 | ajouté  |
+| `crates/ksp-app-config-desk/TODO.md`                   | ajouté  |
+| `crates/ksp-app-config-desk/USAGE.md`                  | ajouté  |
+| `crates/ksp-app-config-desk/build.rs`                  | ajouté  |
+| `crates/ksp-app-config-desk/capabilities/default.json` | ajouté  |
+| `crates/ksp-app-config-desk/icons/favicon.ico`         | ajouté  |
+| `crates/ksp-app-config-desk/icons/favicon.png`         | ajouté  |
+| `crates/ksp-app-config-desk/src/errors.rs`             | ajouté  |
+| `crates/ksp-app-config-desk/src/lib.rs`                | ajouté  |
+| `crates/ksp-app-config-desk/src/main.rs`               | ajouté  |
+| `crates/ksp-app-config-desk/src/tauri.rs`              | ajouté  |
+| `crates/ksp-app-config-desk/tauri.conf.json`           | ajouté  |
+| `crates/ksp-app-config-desk/tests/public_api.rs`       | ajouté  |
+| `deltas/0.1.4/pre.004.md`                              | ajouté  |
+
+## 12. Validation demandée avant commit
+
+Après application du delta :
+
+```bash
+cargo fmt --all
+cargo check --workspace
+cargo clippy --workspace --all-targets
+cargo test -p ksp-app-config-desk
+cargo test -p ksp-config-lib
+cargo tree -p ksp-app-config-desk
+```
+
+`cargo test -p ksp-config-lib` est conservé dans cette tranche parce que l'ajout d'une nouvelle crate workspace doit rester compatible avec les audits d'ownership Config qui parcourent toutes les crates.
+
+`cargo tauri dev` n'est **pas encore** un critère de validation de `pre.004` : `package.json`, Vite et les fichiers HTML/TypeScript sont volontairement introduits dans `pre.005`.
+
+## 13. Suite
+
+Si cette tranche est validée et commitée, `pre.005` introduira le gabarit frontend :
+
+- `package.json` et installation des dépendances ;
+- `vite.config.ts` / `tsconfig.json` ;
+- `frontend/main.html` / `frontend/splash.html` ;
+- `frontend/ts` et `frontend/sass` réels ;
+- Bootstrap, Font Awesome, SimpleBar et `resize-observer-polyfill` ;
+- `tauri-plugin-tracing` + `@fltsci/tauri-plugin-tracing` ;
+- Vite strict `1430`, HMR `1431` ;
+- output `../../builds/khadhroony-solana-project/ksp-app-config-desk/dist` ;
+- premier `cargo tauri dev` du shell minimal.
--- a/docs/plans/006-V0_1_4_CONFIG_DESKTOP_PLAN.md
+++ b/docs/plans/006-V0_1_4_CONFIG_DESKTOP_PLAN.md
@@ -1,5 +1,5 @@
 <!-- file: docs/plans/006-V0_1_4_CONFIG_DESKTOP_PLAN.md -->
-<!-- version: 4 -->
+<!-- version: 5 -->

 # Plan `0.1.4` — `ksp-app-config-desk`

@@ -220,6 +220,28 @@ Aucun framework React/Vue/Svelte n'est nécessaire pour ce manager spécialisé.

 Le premier éditeur raw utilisera un contrôle texte natif correctement stylé ; aucun éditeur de code lourd n'est ajouté tant qu'un besoin fonctionnel ne l'impose pas.

+### 3.4 Conventions frontend, artefacts et ports des applications desk
+
+Le layout frontend reprend la convention éprouvée de bot3 : les sources web sont contenues dans `frontend/`, les modules TypeScript dans `frontend/ts/`, les styles SCSS dans `frontend/sass/` et les bindings TS-RS générés sous `frontend/ts/bindings/`. Les DTO Rust restent propriétaires de leur contrat ; les fichiers TypeScript générés ne sont jamais édités manuellement et `bindings/` reste ignoré par Git.
+
+Les artefacts frontend construits doivent être séparés des sources. Pour `ksp-app-config-desk`, la destination contractuelle est fixée à :
+
+```text
+../../builds/khadhroony-solana-project/ksp-app-config-desk/dist
+```
+
+Cette valeur est utilisée par `build.frontendDist` dans `tauri.conf.json`. `vite.config.ts` utilisera la même destination comme `build.outDir` lors de son introduction. Elle remplace le `../dist`/`../../dist` historique du gabarit bot3.
+
+La gestion npm suit une règle simple : npm est utilisé directement pour installer ou mettre à jour les dépendances (`npm i -D ...`). Le cycle normal de développement et de build passe par Tauri ; `cargo tauri dev` et `cargo tauri build` déclenchent eux-mêmes `npm run dev` / `npm run build` au travers des hooks Tauri. Il n'est pas demandé à l'opérateur de lancer séparément le serveur Vite. Aucun lockfile npm n'est versionné.
+
+Chaque application Tauri desk KSP reçoit un couple de ports Vite/HMR propre. La première application réserve :
+
+| Application           | Port Vite HTTP | Port HMR |
+|-----------------------|---------------:|---------:|
+| `ksp-app-config-desk` |         `1430` |   `1431` |
+
+Les applications suivantes incrémentent le couple de deux ports (`1432/1433`, puis `1434/1435`, etc.). Vite doit utiliser un port strict afin qu'une collision soit signalée au lieu de provoquer un basculement silencieux vers un autre port. Cette allocation permet de faire fonctionner simultanément plusieurs applications desk en mode développement.
+
 ## 4. Audit des dépendances actuelles au 2026-08-16

 Aucune dépendance n'est ajoutée par `pre.001`. Les versions suivantes ont été revérifiées depuis les registres/documentations officiels afin de fixer la génération candidate à réévaluer **au moment exact de l'ajout** :
@@ -329,7 +351,7 @@ crates/ksp-app-config-desk/
 │   │   ├── frontend_log.ts
 │   │   ├── state.ts
 │   │   └── bindings/             # généré, ignoré
-│   └── scss/
+│   └── sass/
 │       ├── main.scss
 │       ├── splash.scss
 │       └── _shared.scss
@@ -1117,10 +1139,16 @@ pre.004  squelette Rust Tauri
         - main.rs/lib.rs/tauri.rs minimaux
         - builder Tauri configuré par étapes courtes/réassignées, sans chaîne monolithique
         - tauri.conf/capabilities/icône
+         - frontendDist externe contractuel
+         - réservation 1430/1431 et convention des couples de ports desk
+         - layout frontend/ts/bindings + frontend/sass fixé sans dépendances npm prématurées
         - single-instance

 pre.005  squelette frontend/gabarit
         - package.json + Vite/TypeScript
+         - npm utilisé pour la gestion des dépendances, cycle dev/build lancé par Tauri
+         - build.outDir identique au frontendDist externe
+         - port Vite 1430 strict + HMR 1431
         - SCSS/Bootstrap/Font Awesome
         - SimpleBar + resize-observer-polyfill comme socle du gabarit
         - @fltsci/tauri-plugin-tracing avec plugin Rust
--- a/docs/rules/RULES_KSP.md
+++ b/docs/rules/RULES_KSP.md
@@ -1,5 +1,5 @@
 <!-- file: docs/rules/RULES_KSP.md -->
-<!-- version: 22 -->
+<!-- version: 23 -->

 # Règles spécifiques à KSP

@@ -214,6 +214,10 @@
 - **KSP-APP-019** — Les applications Tauri KSP utilisent l'écosystème `tracing` à leur frontière desktop via le plugin Tauri de tracing retenu (`tauri-plugin-tracing` ou successeur explicitement validé) et des adapters similaires au modèle éprouvé de khadhroony-bot3. Elles n'utilisent pas `tauri-plugin-log` ni la façade `log`, sauf décision architecturale future explicite qui remplacerait cette règle. L'application ne configure pas directement `tracing-subscriber`/`tracing-appender` : `ksp-logging-lib` reste propriétaire du runtime Logging, le plugin Tauri servant d'adapter d'intégration desktop.
 - **KSP-APP-020** — La première version de `ksp-app-config-desk` n'est clôturable que si l'UI permet de créer, modifier, sauvegarder et sélectionner plusieurs profils Logging, dont au minimum un profil mono-fichier et un profil multi-fichiers avec sorties séparées plus sortie logiciel/console, puis de recharger à chaud la configuration Logging et de constater effectivement le nouveau routage sans redémarrage de l'application.
 - **KSP-APP-021** — `ksp-app-config-desk` est conçu comme un gestionnaire Config extensible : la première version peut fournir un éditeur Logging typé, mais son architecture/navigation/état ne doit pas figer l'application sur `std.logging.json`. De futurs `file_id`, schemas et éditeurs spécialisés doivent pouvoir être ajoutés sans déplacer la propriété des documents, de leur validation ou de leur persistence hors de `ksp-config-lib`.
+- **KSP-APP-022** — La construction d'un `tauri::Builder` KSP reste progressive et lisible : une variable builder est configurée/réassignée par étapes courtes ou helpers ciblés plutôt qu'au moyen d'une longue chaîne monolithique, afin qu'un plugin, state, setup ou groupe de commandes puisse être désactivé sans restructurer l'ensemble du runtime.
+- **KSP-APP-023** — Le gabarit Tauri KSP place les sources web sous `frontend/`, les modules TypeScript sous `frontend/ts/`, les styles SCSS sous `frontend/sass/` et les bindings TS-RS générés sous `frontend/ts/bindings/`. Les bindings et artefacts générés ne sont pas versionnés ; les DTO Rust applicatifs restent la source des contrats TS-RS.
+- **KSP-APP-024** — Chaque application desk Tauri KSP possède un couple de ports Vite/HMR exclusif. L'allocation commence à `1430/1431` pour `ksp-app-config-desk` puis progresse par paires (`1432/1433`, `1434/1435`, etc.). Le port Vite est strict afin qu'une collision échoue explicitement au lieu de sélectionner silencieusement un autre port.
+- **KSP-APP-025** — npm est utilisé directement pour installer ou mettre à jour les dépendances frontend (`npm i -D ...`). Le cycle normal de développement/build d'une application Tauri passe par les commandes Tauri, qui déclenchent les scripts npm configurés via `beforeDevCommand`/`beforeBuildCommand`; les lockfiles frontend restent non versionnés.

 ## Data plane / control plane