build: base CMake, presets et vérification locale

CMake 3.25+, C++20, avertissements stricts, règles de déterminisme (pas de fast-math ni de contraction FMA), sanitizers et clang-tidy optionnels, doctest. Presets Windows/Linux/macOS, scripts build.ps1, build.sh et check.ps1 (pas de CI serveur). README de core, 3d et schema.
2026-11-06 19:32:10 +01:00
1 parent c91bebccba
commit d080da0ee3
@@ -0,0 +1,19 @@
+---
+Language: Cpp
+BasedOnStyle: LLVM
+IndentWidth: 4
+ColumnLimit: 120
+AccessModifierOffset: -4
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterFunction: true
+  AfterClass: false
+  AfterStruct: false
+  AfterNamespace: false
+  BeforeElse: false
+AllowShortFunctionsOnASingleLine: Inline
+PointerAlignment: Left
+NamespaceIndentation: None
+FixNamespaceComments: true
+IncludeBlocks: Regroup
+SortIncludes: CaseSensitive
@@ -0,0 +1,17 @@
+---
+Checks: >
+  -*,
+  bugprone-*,
+  -bugprone-easily-swappable-parameters,
+  cppcoreguidelines-owning-memory,
+  cppcoreguidelines-no-malloc,
+  cppcoreguidelines-pro-type-member-init,
+  modernize-*,
+  -modernize-use-trailing-return-type,
+  performance-*,
+  readability-container-size-empty,
+  readability-make-member-function-const,
+  readability-redundant-*
+WarningsAsErrors: '*'
+HeaderFilterRegex: '(core|3d)/(include|src)/.*'
+FormatStyle: file
@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: MPL-2.0
+#
+# SEQUA 3D : contrat de données, négociation des capacités, I3DEngineAdapter.
+# Cible d'interface vide tant que le contrat n'est pas défini (phase 0, voir schema/).
+
+add_library(sequa_3d INTERFACE)
+add_library(sequa::3d ALIAS sequa_3d)
+
+target_include_directories(sequa_3d INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include")
+target_link_libraries(sequa_3d INTERFACE sequa::core)
@@ -0,0 +1,33 @@
+# SEQUA 3D
+
+## SEQUA Engine en bref
+
+**SEQUA** : *Simulate Environments, Quantify Uncertainty, Adapt.* SEQUA Engine est un environnement de création et d'exécution de mondes virtuels, d'abord pour le jeu vidéo, où l'auteur dirige un monde par l'intention, le ressenti et les règles plutôt que par des paramètres. Il est composé de quatre couches : **Studio** (outil de création web), **Core** (source de vérité), **SEQUA 3D** (seule porte vers un moteur 3D) et des **moteurs 3D** interchangeables (Godot, puis Unreal, puis un moteur maison).
+
+Référence : [docs/SEQUA_Engine_resume_complet_v2.md](../docs/SEQUA_Engine_resume_complet_v2.md)
+
+## Rôle de SEQUA 3D dans l'engine
+
+SEQUA 3D est la couche d'interface 3D, propriété de SEQUA. **C'est par elle, et par elle seule, que SEQUA parle à un moteur 3D** (§7). Elle contient :
+
+- le contrat de données (`NeuralFrameContext`, état du monde, commandes, mesures, §5.6) ;
+- la synchronisation à sens unique du projet SEQUA vers le moteur ;
+- la négociation des capacités : chaque moteur déclare ce qu'il sait produire (profondeur, normales, identifiants d'objets…) ;
+- l'interface `I3DEngineAdapter` que chaque moteur implémente ;
+- la traduction des mesures (temps, VRAM, confiance) vers un format commun.
+
+Elle n'expose aucun concept propre à un moteur (nœuds Godot, acteurs Unreal). Les adaptateurs et agents côté moteur vivent dans des dépôts séparés.
+
+## État
+
+Phase 0. La cible `sequa::3d` est une interface vide en attendant le choix du format de contrat (Protobuf ou FlatBuffers, voir [schema/](../schema)).
+
+## Construire
+
+Construite avec le reste du dépôt : voir [core/README.md](../core/README.md#construire-et-tester).
+
+## Licences
+
+- SEQUA 3D : [MPL 2.0](../LICENSE).
+- Aucune dépendance externe pour l'instant.
+- Les adaptateurs vers des moteurs propriétaires (Unreal) n'entrent que comme plugins facultatifs, l'adaptateur seul étant ouvert (§10.2).
@@ -0,0 +1,37 @@
+# SPDX-License-Identifier: MPL-2.0
+cmake_minimum_required(VERSION 3.25)
+
+project(SEQUA
+    VERSION 0.0.1
+    DESCRIPTION "SEQUA Engine - Simulate Environments, Quantify Uncertainty, Adapt"
+    LANGUAGES CXX)
+
+if(PROJECT_SOURCE_DIR STREQUAL PROJECT_BINARY_DIR)
+    message(FATAL_ERROR "Build dans le dossier source interdit : utiliser un preset (cmake --preset <nom>).")
+endif()
+
+option(SEQUA_BUILD_TESTS "Construire les tests" ON)
+option(SEQUA_WARNINGS_AS_ERRORS "Avertissements traités comme erreurs" ON)
+option(SEQUA_CLANG_TIDY "Lancer clang-tidy pendant la compilation" OFF)
+set(SEQUA_SANITIZERS "" CACHE STRING "Sanitizers à activer (liste : address;undefined)")
+option(SEQUA_BUILD_PROTOTYPES "Construire les prototypes jetables (prototypes/)" OFF)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")
+include(SequaCompilerOptions)
+include(SequaDependencies)
+
+if(SEQUA_BUILD_TESTS)
+    enable_testing()
+endif()
+
+add_subdirectory(core)
+add_subdirectory(3d)
+
+if(SEQUA_BUILD_PROTOTYPES AND EXISTS "${PROJECT_SOURCE_DIR}/prototypes/CMakeLists.txt")
+    add_subdirectory(prototypes)
+endif()
@@ -0,0 +1,95 @@
+{
+  "version": 6,
+  "cmakeMinimumRequired": { "major": 3, "minor": 25, "patch": 0 },
+  "configurePresets": [
+    {
+      "name": "base",
+      "hidden": true,
+      "generator": "Ninja",
+      "binaryDir": "${sourceDir}/build/${presetName}",
+      "cacheVariables": {
+        "SEQUA_BUILD_TESTS": "ON",
+        "SEQUA_WARNINGS_AS_ERRORS": "ON"
+      }
+    },
+    {
+      "name": "windows-base",
+      "hidden": true,
+      "inherits": "base",
+      "cacheVariables": { "CMAKE_CXX_COMPILER": "cl" },
+      "condition": { "type": "equals", "lhs": "${hostSystemName}", "rhs": "Windows" }
+    },
+    {
+      "name": "windows-msvc-debug",
+      "displayName": "Windows MSVC Debug",
+      "inherits": "windows-base",
+      "cacheVariables": { "CMAKE_BUILD_TYPE": "Debug" }
+    },
+    {
+      "name": "windows-msvc-release",
+      "displayName": "Windows MSVC Release",
+      "inherits": "windows-base",
+      "cacheVariables": { "CMAKE_BUILD_TYPE": "RelWithDebInfo" }
+    },
+    {
+      "name": "windows-msvc-asan",
+      "displayName": "Windows MSVC AddressSanitizer",
+      "inherits": "windows-base",
+      "cacheVariables": { "CMAKE_BUILD_TYPE": "Debug", "SEQUA_SANITIZERS": "address" }
+    },
+    {
+      "name": "windows-msvc-prototypes",
+      "displayName": "Windows MSVC Release + prototypes",
+      "inherits": "windows-msvc-release",
+      "cacheVariables": { "SEQUA_BUILD_PROTOTYPES": "ON" }
+    },
+    {
+      "name": "linux-base",
+      "hidden": true,
+      "inherits": "base",
+      "condition": { "type": "equals", "lhs": "${hostSystemName}", "rhs": "Linux" }
+    },
+    {
+      "name": "linux-gcc-debug",
+      "displayName": "Linux GCC Debug",
+      "inherits": "linux-base",
+      "cacheVariables": { "CMAKE_CXX_COMPILER": "g++", "CMAKE_BUILD_TYPE": "Debug" }
+    },
+    {
+      "name": "linux-clang-sanitize",
+      "displayName": "Linux Clang ASan + UBSan",
+      "inherits": "linux-base",
+      "cacheVariables": {
+        "CMAKE_CXX_COMPILER": "clang++",
+        "CMAKE_BUILD_TYPE": "Debug",
+        "SEQUA_SANITIZERS": "address;undefined"
+      }
+    },
+    {
+      "name": "macos-clang-debug",
+      "displayName": "macOS Clang Debug",
+      "inherits": "base",
+      "cacheVariables": { "CMAKE_CXX_COMPILER": "clang++", "CMAKE_BUILD_TYPE": "Debug" },
+      "condition": { "type": "equals", "lhs": "${hostSystemName}", "rhs": "Darwin" }
+    }
+  ],
+  "buildPresets": [
+    { "name": "windows-msvc-debug", "configurePreset": "windows-msvc-debug" },
+    { "name": "windows-msvc-release", "configurePreset": "windows-msvc-release" },
+    { "name": "windows-msvc-asan", "configurePreset": "windows-msvc-asan" },
+    { "name": "windows-msvc-prototypes", "configurePreset": "windows-msvc-prototypes" },
+    { "name": "linux-gcc-debug", "configurePreset": "linux-gcc-debug" },
+    { "name": "linux-clang-sanitize", "configurePreset": "linux-clang-sanitize" },
+    { "name": "macos-clang-debug", "configurePreset": "macos-clang-debug" }
+  ],
+  "testPresets": [
+    { "name": "test-base", "hidden": true, "output": { "outputOnFailure": true }, "execution": { "noTestsAction": "error" } },
+    { "name": "windows-msvc-debug", "inherits": "test-base", "configurePreset": "windows-msvc-debug" },
+    { "name": "windows-msvc-release", "inherits": "test-base", "configurePreset": "windows-msvc-release" },
+    { "name": "windows-msvc-asan", "inherits": "test-base", "configurePreset": "windows-msvc-asan" },
+    { "name": "windows-msvc-prototypes", "inherits": "test-base", "configurePreset": "windows-msvc-prototypes" },
+    { "name": "linux-gcc-debug", "inherits": "test-base", "configurePreset": "linux-gcc-debug" },
+    { "name": "linux-clang-sanitize", "inherits": "test-base", "configurePreset": "linux-clang-sanitize" },
+    { "name": "macos-clang-debug", "inherits": "test-base", "configurePreset": "macos-clang-debug" }
+  ]
+}
@@ -18,12 +18,28 @@ Documentation de référence : [docs/SEQUA_Engine_resume_complet_v2.md](docs/SEQ
 | [schema/](schema) | Contrat de données et protocole Studio↔Core | Protobuf / FlatBuffers |
 | [docs/](docs) | Documentation et décisions d'architecture (`docs/adr/`) | Markdown |
 | [artwork/](artwork) | Identité graphique et sources visuelles | PNG |
+| [prototypes/](prototypes) | Prototypes jetables (ex. échange GPU rendu vers inférence), hors produit | C++ |
+| [cmake/](cmake), [scripts/](scripts) | Options de compilation, build et vérification locaux | CMake, PowerShell, Bash |

 Les adaptateurs de moteurs (Godot, Unreal) vivent dans des dépôts séparés.

 ## État

-Phase 0 : fondations. Rien n'est encore exécutable.
+Phase 0 : fondations. Base de build en place (CMake, presets, tests), pas encore de fonctionnalité.
+
+## Construire et vérifier
+
+Il n'y a pas d'intégration continue sur serveur : les vérifications se lancent localement.
+
+| Plateforme | Commande | Prérequis |
+|---|---|---|
+| Windows | `.\scripts\build.ps1 [-Preset <nom>] [-Clean] [-NoTests]` | Visual Studio 2022 avec outils C++ (MSVC, CMake et Ninja fournis) |
+| Windows, avant commit | `.\scripts\check.ps1` | idem + Node.js pour Studio |
+| Linux / macOS | `./scripts/build.sh [<preset>]` | CMake ≥ 3.25, Ninja, GCC ou Clang |
+
+Presets : `windows-msvc-debug`, `windows-msvc-release`, `windows-msvc-asan`, `windows-msvc-prototypes`, `linux-gcc-debug`, `linux-clang-sanitize`, `macos-clang-debug` (voir `CMakePresets.json`).
+
+Sous Windows PowerShell, si les scripts sont bloqués : `powershell -ExecutionPolicy Bypass -File scripts\build.ps1`.

 ## Licence

@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: MPL-2.0
+#
+# Options de compilation communes à toutes les cibles SEQUA.
+# Les règles de déterminisme suivent docs/SEQUA_Engine_resume_complet_v2.md §10.1 :
+# pas de fast-math, pas de contraction multiplication-addition.
+
+if(SEQUA_CLANG_TIDY)
+    find_program(SEQUA_CLANG_TIDY_EXE NAMES clang-tidy REQUIRED)
+endif()
+
+function(sequa_target_defaults target)
+    if(MSVC)
+        target_compile_options(${target} PRIVATE
+            /W4 /permissive- /utf-8 /Zc:__cplusplus /Zc:preprocessor
+            # Depuis VS 2022, /fp:precise ne contracte plus a*b+c en FMA (seul /fp:contract le fait).
+            /fp:precise)
+        if(SEQUA_WARNINGS_AS_ERRORS)
+            target_compile_options(${target} PRIVATE /WX)
+        endif()
+    else()
+        target_compile_options(${target} PRIVATE
+            -Wall -Wextra -Wpedantic -Wshadow -Wconversion -Wsign-conversion
+            -Wnon-virtual-dtor -Wold-style-cast -Woverloaded-virtual
+            -ffp-contract=off -fno-fast-math)
+        if(SEQUA_WARNINGS_AS_ERRORS)
+            target_compile_options(${target} PRIVATE -Werror)
+        endif()
+    endif()
+
+    if(SEQUA_SANITIZERS)
+        if(MSVC)
+            if("address" IN_LIST SEQUA_SANITIZERS)
+                target_compile_options(${target} PRIVATE /fsanitize=address /Zi)
+                target_link_options(${target} PRIVATE /INCREMENTAL:NO)
+            endif()
+            if("undefined" IN_LIST SEQUA_SANITIZERS)
+                message(STATUS "UBSan n'existe pas sous MSVC : ignoré pour ${target}")
+            endif()
+        else()
+            list(JOIN SEQUA_SANITIZERS "," _sanitizers)
+            target_compile_options(${target} PRIVATE -fsanitize=${_sanitizers} -fno-omit-frame-pointer -fno-sanitize-recover=all)
+            target_link_options(${target} PRIVATE -fsanitize=${_sanitizers})
+        endif()
+    endif()
+
+    if(SEQUA_CLANG_TIDY)
+        set_target_properties(${target} PROPERTIES CXX_CLANG_TIDY "${SEQUA_CLANG_TIDY_EXE}")
+    endif()
+endfunction()
@@ -0,0 +1,19 @@
+# SPDX-License-Identifier: MPL-2.0
+#
+# Dépendances externes, toutes sous licence permissive (voir docs, §10.2).
+
+include(FetchContent)
+
+if(SEQUA_BUILD_TESTS)
+    # doctest : MIT
+    FetchContent_Declare(doctest
+        URL https://github.com/doctest/doctest/archive/refs/tags/v2.4.12.tar.gz
+        DOWNLOAD_EXTRACT_TIMESTAMP TRUE
+        SYSTEM)
+    set(DOCTEST_NO_INSTALL ON CACHE BOOL "" FORCE)
+    FetchContent_MakeAvailable(doctest)
+    # Les déclarations anticipées de std:: par doctest cassent avec les STL récentes.
+    target_compile_definitions(doctest INTERFACE DOCTEST_CONFIG_USE_STD_HEADERS)
+    list(APPEND CMAKE_MODULE_PATH "${doctest_SOURCE_DIR}/scripts/cmake")
+    include(doctest)
+endif()
@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: MPL-2.0
+
+configure_file(src/version_config.hpp.in "${CMAKE_CURRENT_BINARY_DIR}/generated/sequa/core/version_config.hpp" @ONLY)
+
+add_library(sequa_core
+    src/version.cpp)
+add_library(sequa::core ALIAS sequa_core)
+
+target_include_directories(sequa_core
+    PUBLIC
+        "${CMAKE_CURRENT_SOURCE_DIR}/include"
+    PRIVATE
+        "${CMAKE_CURRENT_BINARY_DIR}/generated")
+target_compile_features(sequa_core PUBLIC cxx_std_20)
+sequa_target_defaults(sequa_core)
+
+if(SEQUA_BUILD_TESTS)
+    add_executable(sequa_core_tests
+        tests/main.cpp
+        tests/test_version.cpp)
+    target_link_libraries(sequa_core_tests PRIVATE sequa::core doctest::doctest)
+    sequa_target_defaults(sequa_core_tests)
+    doctest_discover_tests(sequa_core_tests)
+endif()
@@ -0,0 +1,50 @@
+# SEQUA Core
+
+## SEQUA Engine en bref
+
+**SEQUA** : *Simulate Environments, Quantify Uncertainty, Adapt.* SEQUA Engine est un environnement de création et d'exécution de mondes virtuels, d'abord pour le jeu vidéo, où l'auteur dirige un monde par l'intention, le ressenti et les règles plutôt que par des paramètres. Il est composé de quatre couches : **Studio** (outil de création web), **Core** (source de vérité), **SEQUA 3D** (seule porte vers un moteur 3D) et des **moteurs 3D** interchangeables (Godot, puis Unreal, puis un moteur maison).
+
+Référence : [docs/SEQUA_Engine_resume_complet_v2.md](../docs/SEQUA_Engine_resume_complet_v2.md)
+
+## Rôle de Core dans l'engine
+
+Core est la **source de vérité** du projet. Il possède :
+
+- le format de projet et la scène de référence (§5.1) ;
+- la représentation du monde en quatre niveaux, de L0 structurel à L3 génératif (§5.2) ;
+- la simulation déterministe à pas fixe, l'enregistrement des entrées et le rejeu bit à bit (§5.3) ;
+- la couche d'intention ;
+- l'orchestrateur de rendu adaptatif (§5.4) et la mesure de la confiance (§5.5).
+
+**Core ne connaît aucun moteur 3D** : il ne dépend que du contrat de données ([schema/](../schema)). Les modèles neuronaux et génératifs sont exclus de la boucle de simulation.
+
+## État
+
+Phase 0. Seule la bibliothèque `sequa::core` minimale (version) et son test existent. Prochaine étape : simulation déterministe et test de rejeu.
+
+## Construire et tester
+
+Depuis la racine du dépôt :
+
+```powershell
+.\scripts\build.ps1                            # Windows, preset windows-msvc-debug
+.\scripts\build.ps1 -Preset windows-msvc-asan  # AddressSanitizer
+.\scripts\check.ps1                            # tous les presets Windows + Studio
+```
+
+```bash
+./scripts/build.sh                             # Linux / macOS
+```
+
+Règles de déterminisme appliquées à la compilation (§10.1) : pas de fast-math, pas de contraction multiplication-addition (`/fp:precise` sous MSVC, `-ffp-contract=off` ailleurs).
+
+## Licences
+
+- SEQUA Core : [MPL 2.0](../LICENSE).
+- Dépendances :
+
+| Dépendance | Usage | Licence |
+|---|---|---|
+| [doctest](https://github.com/doctest/doctest) 2.4.12 | Tests uniquement | MIT |
+
+Politique (§10.2) : le cœur n'utilise que des dépendances permissives (MIT, BSD, Apache 2.0, zlib).
@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MPL-2.0
+#pragma once
+
+#include <string_view>
+
+namespace sequa::core {
+
+struct Version {
+    int major;
+    int minor;
+    int patch;
+};
+
+[[nodiscard]] Version version() noexcept;
+[[nodiscard]] std::string_view version_string() noexcept;
+
+} // namespace sequa::core
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MPL-2.0
+#include "sequa/core/version.hpp"
+
+#include "sequa/core/version_config.hpp"
+
+namespace sequa::core {
+
+Version version() noexcept
+{
+    return {SEQUA_VERSION_MAJOR, SEQUA_VERSION_MINOR, SEQUA_VERSION_PATCH};
+}
+
+std::string_view version_string() noexcept
+{
+    return SEQUA_VERSION_STRING;
+}
+
+} // namespace sequa::core
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MPL-2.0
+// Fichier généré par CMake : ne pas modifier.
+#pragma once
+
+#define SEQUA_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
+#define SEQUA_VERSION_MINOR @PROJECT_VERSION_MINOR@
+#define SEQUA_VERSION_PATCH @PROJECT_VERSION_PATCH@
+#define SEQUA_VERSION_STRING "@PROJECT_VERSION@"
@@ -0,0 +1,3 @@
+// SPDX-License-Identifier: MPL-2.0
+#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
+#include <doctest/doctest.h>
@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MPL-2.0
+#include "sequa/core/version.hpp"
+
+#include <doctest/doctest.h>
+
+#include <string>
+
+// Noms de tests en ASCII : ctest les affiche tels quels dans toutes les consoles.
+TEST_CASE("version_string correspond a version()")
+{
+    const auto v = sequa::core::version();
+    const auto expected = std::to_string(v.major) + "." + std::to_string(v.minor) + "." + std::to_string(v.patch);
+    CHECK(sequa::core::version_string() == expected);
+}
@@ -0,0 +1,27 @@
+# SEQUA Schema
+
+## SEQUA Engine en bref
+
+**SEQUA** : *Simulate Environments, Quantify Uncertainty, Adapt.* SEQUA Engine est un environnement de création et d'exécution de mondes virtuels, d'abord pour le jeu vidéo, où l'auteur dirige un monde par l'intention, le ressenti et les règles plutôt que par des paramètres. Il est composé de quatre couches : **Studio** (outil de création web), **Core** (source de vérité), **SEQUA 3D** (seule porte vers un moteur 3D) et des **moteurs 3D** interchangeables (Godot, puis Unreal, puis un moteur maison).
+
+Référence : [docs/SEQUA_Engine_resume_complet_v2.md](../docs/SEQUA_Engine_resume_complet_v2.md)
+
+## Rôle du schéma dans l'engine
+
+Ce dossier contient la **définition unique** des échanges de SEQUA. Les types y sont générés à la fois en C++ (Core, SEQUA 3D) et en TypeScript (Studio) :
+
+- le **protocole Studio vers Core** (WebSocket) : commandes, état, événements (§4.8) ;
+- le **contrat de données** entre Core et rendu (§5.6) :
+  - `NeuralFrameContext` : couleur, profondeur, normales, mouvement, albedo, identifiants, masque sémantique, caméra, éclairage, intentions ;
+  - en retour : image, carte de confiance, temps, VRAM, version de l'état du monde.
+
+Le contrat se définit à partir de prototypes et sera révisé plusieurs fois pendant la phase 1.
+
+## État
+
+Vide. Le format (Protobuf ou FlatBuffers) reste à trancher par une ADR dans [docs/adr/](../docs/adr) (§17).
+
+## Licences
+
+- Schémas SEQUA : [MPL 2.0](../LICENSE).
+- Le générateur retenu sera sous licence permissive : Protobuf (BSD 3-Clause) ou FlatBuffers (Apache 2.0).
@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: MPL-2.0
+#
+# Build local Windows : configure, compile et teste un preset CMake.
+# Utilise MSVC, CMake et Ninja fournis par Visual Studio (pas de runner CI).
+# Messages en ASCII : compatible Windows PowerShell 5.1 sans BOM.
+#
+#   .\scripts\build.ps1                          # windows-msvc-debug
+#   .\scripts\build.ps1 -Preset windows-msvc-asan
+#   .\scripts\build.ps1 -Clean -NoTests
+
+[CmdletBinding()]
+param(
+    [string]$Preset = "windows-msvc-debug",
+    [switch]$Clean,
+    [switch]$NoTests
+)
+
+$ErrorActionPreference = "Stop"
+$root = Split-Path -Parent $PSScriptRoot
+
+function Initialize-VsEnvironment {
+    $vswhere = Join-Path ${env:ProgramFiles(x86)} "Microsoft Visual Studio\Installer\vswhere.exe"
+    if (-not (Test-Path $vswhere)) { throw "vswhere introuvable : Visual Studio n'est pas installe." }
+
+    $vs = & $vswhere -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath
+    if (-not $vs) { throw "Aucune installation Visual Studio avec les outils C++ x64." }
+
+    if (-not (Get-Command cl.exe -ErrorAction SilentlyContinue)) {
+        Import-Module (Join-Path $vs "Common7\Tools\Microsoft.VisualStudio.DevShell.dll")
+        Microsoft.VisualStudio.DevShell\Enter-VsDevShell -VsInstallPath $vs -SkipAutomaticLocation `
+            -DevCmdArguments "-arch=x64 -host_arch=x64" | Out-Null
+    }
+
+    # CMake et Ninja de Visual Studio en tete du PATH.
+    $cmakeExt = Join-Path $vs "Common7\IDE\CommonExtensions\Microsoft\CMake"
+    $env:PATH = "$cmakeExt\CMake\bin;$cmakeExt\Ninja;$env:PATH"
+}
+
+function Invoke-Step([string]$label, [scriptblock]$cmd) {
+    Write-Host "==> $label" -ForegroundColor Cyan
+    & $cmd
+    if ($LASTEXITCODE -ne 0) { throw "Echec : $label (code $LASTEXITCODE)" }
+}
+
+Initialize-VsEnvironment
+Push-Location $root
+try {
+    if ($Clean) {
+        $dir = Join-Path $root "build\$Preset"
+        if (Test-Path $dir) { Remove-Item -Recurse -Force $dir }
+    }
+    Invoke-Step "configure $Preset" { cmake --preset $Preset }
+    Invoke-Step "build $Preset" { cmake --build --preset $Preset }
+    if (-not $NoTests) {
+        Invoke-Step "test $Preset" { ctest --preset $Preset }
+    }
+}
+finally {
+    Pop-Location
+}
@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: MPL-2.0
+#
+# Build local Linux / macOS : configure, compile et teste un preset CMake.
+#
+#   ./scripts/build.sh                         # preset par défaut de la plateforme
+#   ./scripts/build.sh linux-clang-sanitize
+#   CLEAN=1 NO_TESTS=1 ./scripts/build.sh
+
+set -euo pipefail
+
+root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+case "$(uname -s)" in
+    Linux)  default_preset="linux-gcc-debug" ;;
+    Darwin) default_preset="macos-clang-debug" ;;
+    *)      echo "Plateforme non gérée : utiliser scripts/build.ps1 sous Windows." >&2; exit 1 ;;
+esac
+preset="${1:-$default_preset}"
+
+cd "$root"
+if [[ "${CLEAN:-0}" == "1" ]]; then
+    rm -rf "build/$preset"
+fi
+
+echo "==> configure $preset"
+cmake --preset "$preset"
+echo "==> build $preset"
+cmake --build --preset "$preset"
+if [[ "${NO_TESTS:-0}" != "1" ]]; then
+    echo "==> test $preset"
+    ctest --preset "$preset"
+fi
@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: MPL-2.0
+#
+# Verification locale complete avant commit (remplace la CI) :
+# tous les presets Windows, puis Studio s'il existe.
+# Messages en ASCII : compatible Windows PowerShell 5.1 sans BOM.
+#
+#   .\scripts\check.ps1
+#   .\scripts\check.ps1 -SkipStudio
+
+[CmdletBinding()]
+param(
+    [switch]$SkipStudio
+)
+
+$ErrorActionPreference = "Stop"
+$root = Split-Path -Parent $PSScriptRoot
+
+foreach ($preset in "windows-msvc-debug", "windows-msvc-release", "windows-msvc-asan") {
+    & (Join-Path $PSScriptRoot "build.ps1") -Preset $preset
+}
+
+$studio = Join-Path $root "studio"
+if (-not $SkipStudio -and (Test-Path (Join-Path $studio "package.json"))) {
+    Push-Location $studio
+    try {
+        Write-Host "==> studio : npm ci" -ForegroundColor Cyan
+        npm ci
+        if ($LASTEXITCODE -ne 0) { throw "Echec : npm ci" }
+        Write-Host "==> studio : npm run check" -ForegroundColor Cyan
+        npm run check
+        if ($LASTEXITCODE -ne 0) { throw "Echec : npm run check" }
+    }
+    finally {
+        Pop-Location
+    }
+}
+
+Write-Host "Verification locale OK" -ForegroundColor Green