L'adaptateur traduit clavier et manette en actions SEQUA (PlayerInput) ;
le Core ne recoit et n'enregistre que ces actions, le rejeu reste exact.
- SEQUA 3D : PlayerInput, poll_input(), capacite player_input
(interface des adaptateurs en version 2)
- protocole Core - rendu 0.2 : render/input, envoye quand les actions
changent ; entree remise au neutre si le rendu disparait
- Godot : InputMap du projet (ZQSD, fleches, espace, manette) ou script
SequaInput.sequa_player_input() pour une correspondance avancee ;
entree neutre sans focus ; exemple examples/sequa_input.gd
- adaptateur debug : entrees scriptees par numero d'image
- Studio : ligne "Entrees du joueur" du panneau Rendu
Contournement de godotengine/godot#124276 : apres chaque image, lecture non filtree de la file de messages (PM_NOREMOVE). Verifie par IsHungAppWindow avec mouvements de souris reels : 0 detection au lieu d'une detection permanente. A retirer quand Godot sera corrige (docs/avant-premiere-version.md).
Studio host passe --render-log (run\render-<port>.log) au Core ; sequa-render journalise toute image de plus de 250 ms avec la repartition du temps, pour diagnostiquer les fenetres Godot qui ne repondent plus.
Port 9180 pris par un autre logiciel (Logitech G HUB) : message et --ui-port au lieu d'une adresse qui mene ailleurs. Points a regler avant la premiere version : docs/avant-premiere-version.md.
- platform/layout : racine sequa-root.json, chemins des composants, arguments et chemins en UTF-8.
- Règles install() : bin/windows-x64/{debug,release,asan}/ (core, render, studio + ui, engines).
- Le Core trouve sequa-render et les adaptateurs depuis la racine (--sequa-root, passé par
Studio host à sa copie fantôme) : plus de render-unavailable depuis le panneau Rendu.
- L'adaptateur Godot cherche Godot et son projet à côté de lui (surcharge par --adapter-options) ;
template_release pour le type release. Godot hébergé dans les presets debug et release.
- scripts/build-all.ps1 : Godot, C++, interface, arrêt des processus du dossier visé, install ;
check.ps1 l'appelle (modification de l'ADR 0004).
- docs/installation/ : compiler, lancer, installer et désinstaller par plateforme.
Carte des processus, échanges WebSocket du panneau Rendu, méthode « le contrat d'abord », fichiers C++ et TypeScript concernés, tests, essai avec le faux Core puis le vrai Core et Godot, liste de contrôle. L'exemple est déjà implémenté : à transformer plus tard en exercices guidés.
Studio demande au Core de démarrer ou d'arrêter le rendu (Godot ou débogage) et affiche son état une fois par seconde : moteur et capacités déclarées, taille, images/s, latence de transport (critère ADR 0009 < 4 ms), délai d'affichage, relances, échecs. Requêtes avec id dans WebSocketCoreConnection, tranche render de l'état et de reduce, connexion simulée et faux Core (SIMULÉ) à jour. Composant render-panel en deux parties : modèle pur testé sous Node, montage DOM testé sous happy-dom (MIT, dépendance de développement). npm run check : 140 tests.
ADR 0009 (Proposée) et spécification du protocole Core - rendu 0.1. Le Core projette le monde simulé (micro-mode 2D, SIMULÉ) en deltas SEQUA 3D (sequa::core_render) et les pousse après chaque tick qui change la scène (RenderHub, observateur de LiveSession) ; il lance et supervise sequa-render (RenderSupervisor : lié au Core, relance après plantage). sequa-render charge une bibliothèque d'adaptateur par un point d'entrée C versionné (3d/adapter_library.hpp), applique les deltas et rend les images ; codec JSON provisoire partagé dans 3d/wire. Adaptateur Godot en DLL et nouvel adaptateur de débogage (engines/debug/adapter : vue de côté en images PPM ou vidéo via ffmpeg externe). Protocole Studio - Core 0.3 : render/start, render/stop, render/status (Core et Studio host). Mesuré avec Godot : transport tick -> delta reçu p95 ≈ 0,3 ms (critère 4 ms).
Le lancement de processus de Studio host (CoreProcess) devient sequa::platform::ChildProcess dans platform/process, pour être partagé par Studio host et le Core (qui lancera le rendu, ADR 0009). Nouvelle option kill_with_parent : l'enfant meurt avec le parent, même brutalement (job object KILL_ON_JOB_CLOSE sous Windows, fork + PR_SET_PDEATHSIG sous Linux, ignorée sous macOS). Les tests de copie fantôme restent dans studio/host/supervisor (test_shadow.cpp) avec l'enfant de test de platform/process.
Option SEQUA_BUILD_GODOT_RUNTIME (preset windows-msvc-prototypes, Windows seulement) : godot-cpp compilé avec l'API du fork si elle a été extraite, même bibliothèque d'exécution MSVC que SEQUA. GodotHost charge la DLL LibGodot, initialise godot-cpp en extension hôte et pilote iteration() ; GodotScene crée, déplace et détruit les nœuds sous SequaScene à partir des deltas validés par SceneState ; conversions pures (rotation, couleur sRGB, formes) testées sans moteur. Démo sequa_godot_demo (scène SIMULÉE) : 300 images, arrêt propre. La DLL de Godot n'est déchargée qu'après les globaux de godot-cpp (init_seg), sinon la sortie du processus plante. Frontière binaire de l'ADR 0008 reportée à l'étape 4 (README de l'adaptateur).
scripts/build-godot.ps1 -Target editor construit l'éditeur du fork (exécutable, pas LibGodot), seul à savoir faire --dump-extension-api, et écrit build/godot/extension_api.json. godot-cpp s'appuie ainsi sur l'API réelle du fork plutôt que sur la liste officielle 4.7 (identiques tant que le fork ne touche pas à l'API : 1036 classes).
Initialiseurs désignés pour ParsedOptions, RequestResult et Error ; candidate non const dans find_ui_dir pour permettre le déplacement au retour ; ErrorCode sur std::uint8_t.
scripts/build-godot.ps1 construit Godot en bibliothèque partagée depuis le fork (SCons dans un venv, Vulkan seul, --path autorisé). Le prototype charge la DLL, démarre Godot par l'interface C de GDExtension et pilote iteration() : démarrage 1,5 s, arrêt propre à condition de décharger la DLL juste après la destruction de l'instance.
GodotEngineAdapter déclare ses capacités Forward+ (start() pas encore écrit). Sous-modules engines/godot/vendor/godot-src (fork Gitea, branche sequa/4.7.2 depuis 4.7.2-stable) et godot-cpp (10.0.0-stable). ADR 0007 : LibGodot, fork, Vulkan, vrai headless, seconde vue pour albedo et identifiants. ADR 0008 : processus de rendu séparé du Core, moteur et inférence en bibliothèques chargées.
Bibliothèque sequa::3d (espace de noms sequa::three_d), sans dépendance à un moteur : interface I3DEngineAdapter, tampons et négociation des capacités, synchronisation de la scène par deltas versionnés tout ou rien (SceneState, snapshot), demandes d'image et mesures communes. NullEngineAdapter (SIMULÉ) pour les tests. Types provisoires en attendant le format du schéma.
StudioHost : rattachement via le fichier d'exécution validé par instanceId, sinon lancement depuis une copie fantôme (jeton aléatoire, origines autorisées, --linked) ; reload = export (enregistrement + empreintes), arrêt, nouvel exécutable, import par rejeu, comparaison tick par tick ; restart ; detach/attach réversibles ; arrêt propre. sequa-studio : options §7.1, interface servie ou --dev, navigateur, commandes console, --watch. Tests de bout en bout contre le vrai Core (rechargement identique, rattachement d'un Core détaché, pas d'orphelin). Interface passée au protocole 0.2, jeton masqué dans le libellé. 111 tests verts en Debug et ASan.
En-têtes repris d'un subagent interrompu, implémentation et tests écrits ensuite : CoreProcess (CreateProcessW avec héritage limité au journal, citation compatible CommandLineToArgvW, journal en ajout ; posix_spawn sous POSIX, non testé), is_process_alive, fichier d'exécution atomique, copies fantômes et nettoyage, read_last_lines, FileWatcher. 15 cas (Debug, ASan) avec un processus enfant de test.
CoreServices / CoreRuntime / LiveSession (conception reprise d'un subagent interrompu, implémentation complétée) : session à 60 Hz avec entrée maintenue, export de l'enregistrement et des empreintes par tick, import par rejeu (sim::rebuild_session) puis poursuite dans le même enregistrement ; bail réversible (--linked, core/attach, core/detach, délai de grâce, code de sortie 3) ; core/shutdown ; jeton en temps constant et contrôle de l'Origin (origines ws:// des clients natifs acceptées, spec mise à jour). Base64 strict corrigé (rejetait des entrées valides). 56 cas de test, ASan vert sur les tests serveur. build.ps1 : -Target accepte a,b.
CoreClient (IXWebSocket) : connexion + hello sequa-studio-host, requêtes corrélées par id avec délais, requêtes concurrentes, erreur immédiate à la déconnexion, rappel on_disconnect. wire : hex64, base64 RFC 4648 strict, décodage des empreintes, first_divergence. 15 cas (Debug, ASan) contre un faux serveur conforme à la spec. Écrit par un subagent (DeepSeek V4.1 Flash), relu.
UiServer (ix::HttpServer) : GET/HEAD, / -> index.html, MIME, en-têtes no-store/nosniff, vérification exclusive du port sous Windows. Chemins : décodage unique, refus de .., ., fichiers cachés, antislash, octet nul, : (lecteur ou flux NTFS), puis confinement vérifié par weakly_canonical. build_ui_url, build_core_ws_url, open_browser (http/https uniquement). 14 cas de test dont 12 tentatives d'évasion. Écrit par un subagent (DeepSeek V4.1 Flash), relu ; refus de : étendu aux flux NTFS.
Studio = host (C++) + ui. Core processus séparé lancé depuis une copie fantôme, lié par un bail réversible porté par le protocole, identifié par instanceId, rechargé par rejeu de la session avec comparaison des empreintes. Sécurité : jeton et vérification de l'Origin.
Studio regroupe l'exécutable hôte (C++, à venir dans studio/host) et l'interface web (TypeScript, studio/ui). Chemins mis à jour dans les scripts, .gitignore et la documentation ; paquet renommé @sequa/studio-ui.
studio/tools/mock-core.mjs : serveur WebSocket RFC 6455 sans dépendance, 6 scénarios (ok, incompatible, error, silent, garbage, close) reproduisant les codes du vrai Core, port 9101 pour coexister avec sequa-core (9100). 7 tests d'intégration contre la vraie WebSocketCoreConnection, dont trames découpées et fusionnées (51 tests au total). scripts/studio.ps1 -MockCore -Scenario <nom> et MOCK_CORE=<nom> pour studio.sh. Écrit par un subagent (GLM 5.3), relu ; port et message du scénario error ajustés.
install-cudnn.ps1 : version la plus récente lue dans l'index NVIDIA, archive cuda13 téléchargée avec reprise et vérifiée par SHA256, licence NVIDIA affichée et acceptée par l'utilisateur, installation sans droits admin dans %LOCALAPPDATA%\SEQUA\sdk\cudnn, variable utilisateur CUDNN_PATH. Refuse de remplacer un dossier de destination non vide qui n'est pas une installation cuDNN. Fonctions de téléchargement et d'empreinte factorisées dans scripts/lib/SequaDownload.ps1 (install-cuda.ps1 inchangé fonctionnellement). Écrit par un subagent (DeepSeek V4.1 Flash), relu et corrigé.
Code 8 observé alors que l'installation manuelle fonctionne : le script vérifie désormais la présence de CUDA après coup et, en cas d'échec, indique le chemin de l'installateur vérifié pour un lancement manuel.
sequa::core_server : ProtocolSession (poignée de main hello -> welcome/error, JSON provisoire identique à Studio, même règle de compatibilité) séparée du transport CoreServer (IXWebSocket 12.1.0, écoute 127.0.0.1:9100). Exécutable sequa-core. Vérification exclusive du port sous Windows (IXWebSocket active SO_REUSEADDR). Sanitizers appliqués à tout le build (ASan MSVC exige des dépendances instrumentées). ADR 0005. 30 tests (Debug, Release, ASan), dont 4 sur vrais sockets.
CUDA 13.5 : import 0,07 ms, mappage 0,05-0,08 ms, copie GPU->GPU 0,06 ms (100-140 Go/s) contre ~32 ms par le CPU, vérification octet à octet OK. Corrige aussi un nom de test contenant ';' que ctest découpait en deux.
Code Vulkan commun factorisé dans vk_common (étape 1 inchangée et verte). Nouvel exécutable gpu_interop_vk_cuda : sélection du device CUDA par deviceUUID, cudaImportExternalMemory OPAQUE_WIN32 dédié, mappage en mipmapped array, copie GPU->GPU mesurée, vérification octet à octet. Construit seulement si le CUDA Toolkit est présent ; pas encore compilé contre les vrais en-têtes ni exécuté.
scripts/studio.ps1 et studio.sh lancent Vite (npm ci automatique, Core simule ou -Core ws://...). install-cuda.ps1 lit le nom de l'installateur et son MD5 dans la liste officielle NVIDIA (md5sum.txt) au lieu du manifeste winget. Aide integree (-Help, Get-Help) pour tous les scripts PowerShell.
Consigne les décisions déjà prises : licence MPL 2.0 et politique de dépendances, deux langages de produit (C++ et TypeScript), Studio web à conteneur remplaçable, multiplateforme par conception avec vérification locale (pas de runners CI).
Virgule fixe Q16.16, générateur PCG32 à graine explicite, horloge à pas fixe exacte, simulation d'un micro-mode de démonstration (marqué SIMULÉ), empreinte FNV-1a de l'état, enregistrement binaire versionné des entrées, rejeu avec d'autres réglages de ressenti et détection du premier tick divergent. Empreinte de référence multiplateforme figée. 22 tests (Debug, Release, ASan).
Client WebSocket sans bibliothèque derrière CoreConnection, messages JSON provisoires hello/welcome/error validés (en attendant l'ADR du schéma), délai de poignée de main, compatibilité semver stricte en 0.x, choix du Core par ?core=ws://..., Core simulé par défaut et affiché comme tel. 44 tests.
L'installateur (~2,7 Go) est téléchargé par curl -C - dans un cache local et reprend après interruption ou relance du script ; URL et SHA256 lus dans le manifeste winget ; options -DryRun et -DownloadOnly ; SHA256 calculé via .NET.
Vérifie la version CUDA acceptée par le pilote et les installations existantes, mode -DryRun, licence NVIDIA acceptée par l'utilisateur (--interactive).
Studio : Vite + TypeScript strict sans framework, état sérialisable et réduction pure, connexion au Core simulée et marquée comme telle, tests vitest. Prototype jetable gpu_interop étape 1 : export/import mémoire Vulkan OPAQUE_WIN32 entre deux VkDevice, vérification octet à octet et mesures.
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.
